6662 lines
292 KiB
C#
6662 lines
292 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Terraria.GameContent.Drawing.TileDrawing
|
|
// Assembly: Terraria, Version=1.4.0.5, Culture=neutral, PublicKeyToken=null
|
|
// MVID: 67F9E73E-0A81-4937-A22C-5515CD405A83
|
|
// Assembly location: C:\Users\mikeyisbaeyt\Downloads\depotdownloader-2.4.5\depots\105601\6707058\Terraria.exe
|
|
|
|
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using ReLogic.Content;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Threading;
|
|
using Terraria.DataStructures;
|
|
using Terraria.GameContent.Events;
|
|
using Terraria.GameContent.Tile_Entities;
|
|
using Terraria.Graphics.Capture;
|
|
using Terraria.ID;
|
|
using Terraria.ObjectData;
|
|
using Terraria.UI;
|
|
using Terraria.Utilities;
|
|
|
|
namespace Terraria.GameContent.Drawing
|
|
{
|
|
public class TileDrawing
|
|
{
|
|
private const int MAX_SPECIALS = 9000;
|
|
private const int MAX_SPECIALS_LEGACY = 1000;
|
|
private const float FORCE_FOR_MIN_WIND = 0.08f;
|
|
private const float FORCE_FOR_MAX_WIND = 1.2f;
|
|
private int _leafFrequency = 100000;
|
|
private int[] _specialsCount = new int[12];
|
|
private Point[][] _specialPositions = new Point[12][];
|
|
private Dictionary<Point, int> _displayDollTileEntityPositions = new Dictionary<Point, int>();
|
|
private Dictionary<Point, int> _hatRackTileEntityPositions = new Dictionary<Point, int>();
|
|
private Dictionary<Point, int> _trainingDummyTileEntityPositions = new Dictionary<Point, int>();
|
|
private Dictionary<Point, int> _itemFrameTileEntityPositions = new Dictionary<Point, int>();
|
|
private Dictionary<Point, int> _foodPlatterTileEntityPositions = new Dictionary<Point, int>();
|
|
private Dictionary<Point, int> _weaponRackTileEntityPositions = new Dictionary<Point, int>();
|
|
private Dictionary<Point, int> _chestPositions = new Dictionary<Point, int>();
|
|
private int _specialTilesCount;
|
|
private int[] _specialTileX = new int[1000];
|
|
private int[] _specialTileY = new int[1000];
|
|
private UnifiedRandom _rand;
|
|
private double _treeWindCounter;
|
|
private double _grassWindCounter;
|
|
private double _sunflowerWindCounter;
|
|
private double _vineWindCounter;
|
|
private WindGrid _windGrid = new WindGrid();
|
|
private bool _shouldShowInvisibleBlocks;
|
|
private List<Point> _vineRootsPositions = new List<Point>();
|
|
private List<Point> _reverseVineRootsPositions = new List<Point>();
|
|
private TilePaintSystemV2 _paintSystem;
|
|
private Color _martianGlow = new Color(0, 0, 0, 0);
|
|
private Color _meteorGlow = new Color(100, 100, 100, 0);
|
|
private Color _lavaMossGlow = new Color(150, 100, 50, 0);
|
|
private Color _kryptonMossGlow = new Color(0, 200, 0, 0);
|
|
private Color _xenonMossGlow = new Color(0, 180, 250, 0);
|
|
private Color _argonMossGlow = new Color(225, 0, 125, 0);
|
|
private bool _isActiveAndNotPaused;
|
|
private Player _localPlayer = new Player();
|
|
private Color _highQualityLightingRequirement;
|
|
private Color _mediumQualityLightingRequirement;
|
|
private static readonly Vector2 _zero;
|
|
private ThreadLocal<TileDrawInfo> _currentTileDrawInfo = new ThreadLocal<TileDrawInfo>((Func<TileDrawInfo>) (() => new TileDrawInfo()));
|
|
private TileDrawInfo _currentTileDrawInfoNonThreaded = new TileDrawInfo();
|
|
private Vector3[] _glowPaintColorSlices = new Vector3[9]
|
|
{
|
|
Vector3.One,
|
|
Vector3.One,
|
|
Vector3.One,
|
|
Vector3.One,
|
|
Vector3.One,
|
|
Vector3.One,
|
|
Vector3.One,
|
|
Vector3.One,
|
|
Vector3.One
|
|
};
|
|
private List<DrawData> _voidLensData = new List<DrawData>();
|
|
|
|
private void AddSpecialPoint(int x, int y, TileDrawing.TileCounterType type) => this._specialPositions[(int) type][this._specialsCount[(int) type]++] = new Point(x, y);
|
|
|
|
private bool[] _tileSolid => Main.tileSolid;
|
|
|
|
private bool[] _tileSolidTop => Main.tileSolidTop;
|
|
|
|
private Dust[] _dust => Main.dust;
|
|
|
|
private Gore[] _gore => Main.gore;
|
|
|
|
public TileDrawing(TilePaintSystemV2 paintSystem)
|
|
{
|
|
this._paintSystem = paintSystem;
|
|
this._rand = new UnifiedRandom();
|
|
for (int index = 0; index < this._specialPositions.Length; ++index)
|
|
this._specialPositions[index] = new Point[9000];
|
|
}
|
|
|
|
public void PreparePaintForTilesOnScreen()
|
|
{
|
|
if (Main.GameUpdateCount % 6U > 0U)
|
|
return;
|
|
Vector2 unscaledPosition = Main.Camera.UnscaledPosition;
|
|
Vector2 vector2 = new Vector2((float) Main.offScreenRange, (float) Main.offScreenRange);
|
|
if (Main.drawToScreen)
|
|
vector2 = Vector2.Zero;
|
|
int firstTileX;
|
|
int lastTileX;
|
|
int firstTileY;
|
|
int lastTileY;
|
|
this.GetScreenDrawArea(unscaledPosition, vector2 + (Main.Camera.UnscaledPosition - Main.Camera.ScaledPosition), out firstTileX, out lastTileX, out firstTileY, out lastTileY);
|
|
this.PrepareForAreaDrawing(firstTileX, lastTileX, firstTileY, lastTileY, true);
|
|
}
|
|
|
|
public void PrepareForAreaDrawing(
|
|
int firstTileX,
|
|
int lastTileX,
|
|
int firstTileY,
|
|
int lastTileY,
|
|
bool prepareLazily)
|
|
{
|
|
TilePaintSystemV2.TileVariationkey lookupKey1 = new TilePaintSystemV2.TileVariationkey();
|
|
TilePaintSystemV2.WallVariationKey lookupKey2 = new TilePaintSystemV2.WallVariationKey();
|
|
for (int index1 = firstTileY; index1 < lastTileY + 4; ++index1)
|
|
{
|
|
for (int index2 = firstTileX - 2; index2 < lastTileX + 2; ++index2)
|
|
{
|
|
Tile tile = Main.tile[index2, index1];
|
|
if (tile != null)
|
|
{
|
|
if (tile.active())
|
|
{
|
|
Main.instance.LoadTiles((int) tile.type);
|
|
lookupKey1.TileType = (int) tile.type;
|
|
lookupKey1.PaintColor = (int) tile.color();
|
|
int num = 0;
|
|
switch (tile.type)
|
|
{
|
|
case 5:
|
|
num = TileDrawing.GetTreeBiome(index2, index1, (int) tile.frameX, (int) tile.frameY);
|
|
break;
|
|
case 323:
|
|
num = this.GetPalmTreeBiome(index2, index1);
|
|
break;
|
|
}
|
|
lookupKey1.TileStyle = num;
|
|
if (lookupKey1.PaintColor != 0)
|
|
this._paintSystem.RequestTile(ref lookupKey1);
|
|
}
|
|
if (tile.wall != (ushort) 0)
|
|
{
|
|
Main.instance.LoadWall((int) tile.wall);
|
|
lookupKey2.WallType = (int) tile.wall;
|
|
lookupKey2.PaintColor = (int) tile.wallColor();
|
|
if (lookupKey2.PaintColor != 0)
|
|
this._paintSystem.RequestWall(ref lookupKey2);
|
|
}
|
|
if (!prepareLazily)
|
|
this.MakeExtraPreparations(tile, index2, index1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void MakeExtraPreparations(Tile tile, int x, int y)
|
|
{
|
|
switch (tile.type)
|
|
{
|
|
case 5:
|
|
int treeFrame1 = 0;
|
|
int floorY1 = 0;
|
|
int topTextureFrameWidth1 = 0;
|
|
int topTextureFrameHeight1 = 0;
|
|
int treeStyle1 = 0;
|
|
int xoffset1 = (tile.frameX == (short) 44).ToInt() - (tile.frameX == (short) 66).ToInt();
|
|
if (!WorldGen.GetCommonTreeFoliageData(x, y, xoffset1, ref treeFrame1, ref treeStyle1, out floorY1, out topTextureFrameWidth1, out topTextureFrameHeight1))
|
|
break;
|
|
TilePaintSystemV2.TreeFoliageVariantKey lookupKey1 = new TilePaintSystemV2.TreeFoliageVariantKey()
|
|
{
|
|
TextureIndex = treeStyle1,
|
|
PaintColor = (int) tile.color()
|
|
};
|
|
this._paintSystem.RequestTreeTop(ref lookupKey1);
|
|
this._paintSystem.RequestTreeBranch(ref lookupKey1);
|
|
break;
|
|
case 323:
|
|
int num = 15;
|
|
if (x >= WorldGen.beachDistance && x <= Main.maxTilesX - WorldGen.beachDistance)
|
|
num = 21;
|
|
TilePaintSystemV2.TreeFoliageVariantKey lookupKey2 = new TilePaintSystemV2.TreeFoliageVariantKey()
|
|
{
|
|
TextureIndex = num,
|
|
PaintColor = (int) tile.color()
|
|
};
|
|
this._paintSystem.RequestTreeTop(ref lookupKey2);
|
|
this._paintSystem.RequestTreeBranch(ref lookupKey2);
|
|
break;
|
|
case 583:
|
|
case 584:
|
|
case 585:
|
|
case 586:
|
|
case 587:
|
|
case 588:
|
|
case 589:
|
|
int treeFrame2 = 0;
|
|
int floorY2 = 0;
|
|
int topTextureFrameWidth2 = 0;
|
|
int topTextureFrameHeight2 = 0;
|
|
int treeStyle2 = 0;
|
|
int xoffset2 = (tile.frameX == (short) 44).ToInt() - (tile.frameX == (short) 66).ToInt();
|
|
if (!WorldGen.GetGemTreeFoliageData(x, y, xoffset2, ref treeFrame2, ref treeStyle2, out floorY2, out topTextureFrameWidth2, out topTextureFrameHeight2))
|
|
break;
|
|
TilePaintSystemV2.TreeFoliageVariantKey lookupKey3 = new TilePaintSystemV2.TreeFoliageVariantKey()
|
|
{
|
|
TextureIndex = treeStyle2,
|
|
PaintColor = (int) tile.color()
|
|
};
|
|
this._paintSystem.RequestTreeTop(ref lookupKey3);
|
|
this._paintSystem.RequestTreeBranch(ref lookupKey3);
|
|
break;
|
|
case 596:
|
|
case 616:
|
|
int treeFrame3 = 0;
|
|
int floorY3 = 0;
|
|
int topTextureFrameWidth3 = 0;
|
|
int topTextureFrameHeight3 = 0;
|
|
int treeStyle3 = 0;
|
|
int xoffset3 = (tile.frameX == (short) 44).ToInt() - (tile.frameX == (short) 66).ToInt();
|
|
if (!WorldGen.GetVanityTreeFoliageData(x, y, xoffset3, ref treeFrame3, ref treeStyle3, out floorY3, out topTextureFrameWidth3, out topTextureFrameHeight3))
|
|
break;
|
|
TilePaintSystemV2.TreeFoliageVariantKey lookupKey4 = new TilePaintSystemV2.TreeFoliageVariantKey()
|
|
{
|
|
TextureIndex = treeStyle3,
|
|
PaintColor = (int) tile.color()
|
|
};
|
|
this._paintSystem.RequestTreeTop(ref lookupKey4);
|
|
this._paintSystem.RequestTreeBranch(ref lookupKey4);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void Update()
|
|
{
|
|
double lerpValue = (double) Utils.GetLerpValue(0.08f, 1.2f, Math.Abs(Main.WindForVisuals), true);
|
|
this._treeWindCounter += 1.0 / 240.0 + 1.0 / 240.0 * lerpValue * 2.0;
|
|
this._grassWindCounter += 1.0 / 180.0 + 1.0 / 180.0 * lerpValue * 4.0;
|
|
this._sunflowerWindCounter += 1.0 / 420.0 + 1.0 / 420.0 * lerpValue * 5.0;
|
|
this._vineWindCounter += 1.0 / 120.0 + 1.0 / 120.0 * lerpValue * 0.400000005960464;
|
|
this.UpdateLeafFrequency();
|
|
this.EnsureWindGridSize();
|
|
this._windGrid.Update();
|
|
this._shouldShowInvisibleBlocks = Main.LocalPlayer.CanSeeInvisibleBlocks;
|
|
}
|
|
|
|
public void PreDrawTiles(bool solidLayer, bool forRenderTargets, bool intoRenderTargets)
|
|
{
|
|
bool flag = intoRenderTargets || Lighting.UpdateEveryFrame;
|
|
if (!(!solidLayer & flag))
|
|
return;
|
|
this._specialsCount[5] = 0;
|
|
this._specialsCount[4] = 0;
|
|
this._specialsCount[8] = 0;
|
|
this._specialsCount[6] = 0;
|
|
this._specialsCount[3] = 0;
|
|
this._specialsCount[0] = 0;
|
|
this._specialsCount[9] = 0;
|
|
this._specialsCount[10] = 0;
|
|
this._specialsCount[11] = 0;
|
|
}
|
|
|
|
public void PostDrawTiles(bool solidLayer, bool forRenderTargets, bool intoRenderTargets)
|
|
{
|
|
if (!solidLayer && !intoRenderTargets)
|
|
{
|
|
Main.spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.AlphaBlend, Main.DefaultSamplerState, DepthStencilState.None, Main.Rasterizer, (Effect) null, Main.Transform);
|
|
this.DrawMultiTileVines();
|
|
this.DrawMultiTileGrass();
|
|
this.DrawVoidLenses();
|
|
this.DrawTeleportationPylons();
|
|
this.DrawMasterTrophies();
|
|
this.DrawGrass();
|
|
this.DrawTrees();
|
|
this.DrawVines();
|
|
this.DrawReverseVines();
|
|
Main.spriteBatch.End();
|
|
}
|
|
if (!solidLayer || intoRenderTargets)
|
|
return;
|
|
this.DrawEntities_HatRacks();
|
|
this.DrawEntities_DisplayDolls();
|
|
}
|
|
|
|
public void Draw(
|
|
bool solidLayer,
|
|
bool forRenderTargets,
|
|
bool intoRenderTargets,
|
|
int waterStyleOverride = -1)
|
|
{
|
|
Stopwatch stopwatch = new Stopwatch();
|
|
stopwatch.Start();
|
|
this._isActiveAndNotPaused = !Main.gamePaused && Main.instance.IsActive;
|
|
this._localPlayer = Main.LocalPlayer;
|
|
Vector2 unscaledPosition = Main.Camera.UnscaledPosition;
|
|
Vector2 vector2 = new Vector2((float) Main.offScreenRange, (float) Main.offScreenRange);
|
|
if (Main.drawToScreen)
|
|
vector2 = Vector2.Zero;
|
|
if (!solidLayer)
|
|
Main.critterCage = false;
|
|
this.EnsureWindGridSize();
|
|
this.ClearLegacyCachedDraws();
|
|
bool flag = intoRenderTargets || Main.LightingEveryFrame;
|
|
if (flag)
|
|
this.ClearCachedTileDraws(solidLayer);
|
|
float num1 = (float) ((double) byte.MaxValue * (1.0 - (double) Main.gfxQuality) + 30.0 * (double) Main.gfxQuality);
|
|
this._highQualityLightingRequirement.R = (byte) num1;
|
|
this._highQualityLightingRequirement.G = (byte) ((double) num1 * 1.1);
|
|
this._highQualityLightingRequirement.B = (byte) ((double) num1 * 1.2);
|
|
float num2 = (float) (50.0 * (1.0 - (double) Main.gfxQuality) + 2.0 * (double) Main.gfxQuality);
|
|
this._mediumQualityLightingRequirement.R = (byte) num2;
|
|
this._mediumQualityLightingRequirement.G = (byte) ((double) num2 * 1.1);
|
|
this._mediumQualityLightingRequirement.B = (byte) ((double) num2 * 1.2);
|
|
int firstTileX;
|
|
int lastTileX;
|
|
int firstTileY;
|
|
int lastTileY;
|
|
this.GetScreenDrawArea(unscaledPosition, vector2 + (Main.Camera.UnscaledPosition - Main.Camera.ScaledPosition), out firstTileX, out lastTileX, out firstTileY, out lastTileY);
|
|
byte num3 = (byte) (100.0 + 150.0 * (double) Main.martianLight);
|
|
this._martianGlow = new Color((int) num3, (int) num3, (int) num3, 0);
|
|
TileDrawInfo drawData = this._currentTileDrawInfo.Value;
|
|
for (int index1 = firstTileY; index1 < lastTileY + 4; ++index1)
|
|
{
|
|
for (int index2 = firstTileX - 2; index2 < lastTileX + 2; ++index2)
|
|
{
|
|
Tile tileCache = Main.tile[index2, index1];
|
|
if (tileCache == null)
|
|
{
|
|
Tile tile = new Tile();
|
|
Main.tile[index2, index1] = tile;
|
|
Main.mapTime += 60;
|
|
}
|
|
else if (tileCache.active() && this.IsTileDrawLayerSolid(tileCache.type) == solidLayer)
|
|
{
|
|
ushort type = tileCache.type;
|
|
short frameX = tileCache.frameX;
|
|
short frameY = tileCache.frameY;
|
|
if (!TextureAssets.Tile[(int) type].IsLoaded)
|
|
Main.instance.LoadTiles((int) type);
|
|
switch (type)
|
|
{
|
|
case 27:
|
|
if ((((int) frameX % 36 != 0 ? 0 : (frameY == (short) 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileGrass);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 34:
|
|
if ((((int) frameX % 54 != 0 ? 0 : ((int) frameY % 54 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileVine);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 42:
|
|
case 270:
|
|
case 271:
|
|
case 572:
|
|
case 581:
|
|
if ((((int) frameX % 18 != 0 ? 0 : ((int) frameY % 36 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileVine);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 52:
|
|
case 62:
|
|
case 115:
|
|
case 205:
|
|
case 382:
|
|
case 528:
|
|
if (flag)
|
|
{
|
|
this.CrawlToTopOfVineAndAddSpecialPoint(index1, index2);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 91:
|
|
if ((((int) frameX % 18 != 0 ? 0 : ((int) frameY % 54 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileVine);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 95:
|
|
case 126:
|
|
case 444:
|
|
if ((((int) frameX % 36 != 0 ? 0 : ((int) frameY % 36 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileVine);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 233:
|
|
if (((frameY != (short) 0 ? 0 : ((int) frameX % 54 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileGrass);
|
|
if (((frameY != (short) 34 ? 0 : ((int) frameX % 36 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileGrass);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 236:
|
|
case 238:
|
|
if ((((int) frameX % 36 != 0 ? 0 : (frameY == (short) 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileGrass);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 373:
|
|
case 374:
|
|
case 375:
|
|
case 461:
|
|
this.EmitLiquidDrops(index1, index2, tileCache, type);
|
|
continue;
|
|
case 454:
|
|
if ((((int) frameX % 72 != 0 ? 0 : ((int) frameY % 54 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileVine);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 465:
|
|
case 591:
|
|
case 592:
|
|
if ((((int) frameX % 36 != 0 ? 0 : ((int) frameY % 54 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileVine);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 485:
|
|
case 489:
|
|
case 490:
|
|
if (((frameY != (short) 0 ? 0 : ((int) frameX % 36 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileGrass);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 491:
|
|
if (flag && frameX == (short) 18 && frameY == (short) 18)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.VoidLens);
|
|
break;
|
|
}
|
|
break;
|
|
case 493:
|
|
if (((frameY != (short) 0 ? 0 : ((int) frameX % 18 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileGrass);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 519:
|
|
if ((int) frameX / 18 <= 4 & flag)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileGrass);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 521:
|
|
case 522:
|
|
case 523:
|
|
case 524:
|
|
case 525:
|
|
case 526:
|
|
case 527:
|
|
if (((frameY != (short) 0 ? 0 : ((int) frameX % 36 == 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileGrass);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 530:
|
|
if (frameX < (short) 270)
|
|
{
|
|
if ((((int) frameX % 54 != 0 ? 0 : (frameY == (short) 0 ? 1 : 0)) & (flag ? 1 : 0)) != 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MultiTileGrass);
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
break;
|
|
case 541:
|
|
if (this._shouldShowInvisibleBlocks)
|
|
break;
|
|
continue;
|
|
case 549:
|
|
if (flag)
|
|
{
|
|
this.CrawlToBottomOfReverseVineAndAddSpecialPoint(index1, index2);
|
|
continue;
|
|
}
|
|
continue;
|
|
case 597:
|
|
if (flag && (int) frameX % 54 == 0 && frameY == (short) 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.TeleportationPylon);
|
|
break;
|
|
}
|
|
break;
|
|
case 617:
|
|
if (flag && (int) frameX % 54 == 0 && (int) frameY % 72 == 0)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.MasterTrophy);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
if (this.ShouldSwayInWind(index2, index1, tileCache))
|
|
{
|
|
if (flag)
|
|
{
|
|
this.AddSpecialPoint(index2, index1, TileDrawing.TileCounterType.WindyGrass);
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
this.DrawSingleTile(drawData, solidLayer, waterStyleOverride, unscaledPosition, vector2, index2, index1);
|
|
}
|
|
}
|
|
}
|
|
if (solidLayer)
|
|
{
|
|
Main.instance.DrawTileCracks(1, Main.player[Main.myPlayer].hitReplace);
|
|
Main.instance.DrawTileCracks(1, Main.player[Main.myPlayer].hitTile);
|
|
}
|
|
this.DrawSpecialTilesLegacy(unscaledPosition, vector2);
|
|
if (TileObject.objectPreview.Active && this._localPlayer.cursorItemIconEnabled && Main.placementPreview && !CaptureManager.Instance.Active)
|
|
{
|
|
Main.instance.LoadTiles((int) TileObject.objectPreview.Type);
|
|
TileObject.DrawPreview(Main.spriteBatch, TileObject.objectPreview, unscaledPosition - vector2);
|
|
}
|
|
if (solidLayer)
|
|
TimeLogger.DrawTime(0, stopwatch.Elapsed.TotalMilliseconds);
|
|
else
|
|
TimeLogger.DrawTime(1, stopwatch.Elapsed.TotalMilliseconds);
|
|
}
|
|
|
|
private void CrawlToTopOfVineAndAddSpecialPoint(int j, int i)
|
|
{
|
|
int y = j;
|
|
for (int j1 = j - 1; j1 > 0; --j1)
|
|
{
|
|
Tile tile = Main.tile[i, j1];
|
|
if (WorldGen.SolidTile(i, j1) || !tile.active())
|
|
{
|
|
y = j1 + 1;
|
|
break;
|
|
}
|
|
}
|
|
Point point = new Point(i, y);
|
|
if (this._vineRootsPositions.Contains(point))
|
|
return;
|
|
this._vineRootsPositions.Add(point);
|
|
this.AddSpecialPoint(i, y, TileDrawing.TileCounterType.Vine);
|
|
}
|
|
|
|
private void CrawlToBottomOfReverseVineAndAddSpecialPoint(int j, int i)
|
|
{
|
|
int y = j;
|
|
for (int j1 = j; j1 < Main.maxTilesY; ++j1)
|
|
{
|
|
Tile tile = Main.tile[i, j1];
|
|
if (WorldGen.SolidTile(i, j1) || !tile.active())
|
|
{
|
|
y = j1 - 1;
|
|
break;
|
|
}
|
|
}
|
|
Point point = new Point(i, y);
|
|
if (this._reverseVineRootsPositions.Contains(point))
|
|
return;
|
|
this._reverseVineRootsPositions.Add(point);
|
|
this.AddSpecialPoint(i, y, TileDrawing.TileCounterType.ReverseVine);
|
|
}
|
|
|
|
private void DrawSingleTile(
|
|
TileDrawInfo drawData,
|
|
bool solidLayer,
|
|
int waterStyleOverride,
|
|
Vector2 screenPosition,
|
|
Vector2 screenOffset,
|
|
int tileX,
|
|
int tileY)
|
|
{
|
|
drawData.tileCache = Main.tile[tileX, tileY];
|
|
drawData.typeCache = drawData.tileCache.type;
|
|
drawData.tileFrameX = drawData.tileCache.frameX;
|
|
drawData.tileFrameY = drawData.tileCache.frameY;
|
|
drawData.tileLight = Lighting.GetColor(tileX, tileY);
|
|
if (drawData.tileCache.liquid > (byte) 0 && drawData.tileCache.type == (ushort) 518)
|
|
return;
|
|
this.GetTileDrawData(tileX, tileY, drawData.tileCache, drawData.typeCache, ref drawData.tileFrameX, ref drawData.tileFrameY, out drawData.tileWidth, out drawData.tileHeight, out drawData.tileTop, out drawData.halfBrickHeight, out drawData.addFrX, out drawData.addFrY, out drawData.tileSpriteEffect, out drawData.glowTexture, out drawData.glowSourceRect, out drawData.glowColor);
|
|
drawData.drawTexture = this.GetTileDrawTexture(drawData.tileCache, tileX, tileY);
|
|
Texture2D highlightTexture = (Texture2D) null;
|
|
Rectangle rectangle1 = Rectangle.Empty;
|
|
Color transparent = Color.Transparent;
|
|
if (TileID.Sets.HasOutlines[(int) drawData.typeCache])
|
|
this.GetTileOutlineInfo(tileX, tileY, drawData.typeCache, ref drawData.tileLight, ref highlightTexture, ref transparent);
|
|
if (this._localPlayer.dangerSense && TileDrawing.IsTileDangerous(this._localPlayer, drawData.tileCache, drawData.typeCache))
|
|
{
|
|
if (drawData.tileLight.R < byte.MaxValue)
|
|
drawData.tileLight.R = byte.MaxValue;
|
|
if (drawData.tileLight.G < (byte) 50)
|
|
drawData.tileLight.G = (byte) 50;
|
|
if (drawData.tileLight.B < (byte) 50)
|
|
drawData.tileLight.B = (byte) 50;
|
|
if (this._isActiveAndNotPaused && this._rand.Next(30) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (tileX * 16), (float) (tileY * 16)), 16, 16, 60, Alpha: 100, Scale: 0.3f);
|
|
this._dust[index].fadeIn = 1f;
|
|
this._dust[index].velocity *= 0.1f;
|
|
this._dust[index].noLight = true;
|
|
this._dust[index].noGravity = true;
|
|
}
|
|
}
|
|
if (this._localPlayer.findTreasure && Main.IsTileSpelunkable(drawData.typeCache, drawData.tileFrameX, drawData.tileFrameY))
|
|
{
|
|
if (drawData.tileLight.R < (byte) 200)
|
|
drawData.tileLight.R = (byte) 200;
|
|
if (drawData.tileLight.G < (byte) 170)
|
|
drawData.tileLight.G = (byte) 170;
|
|
if (this._isActiveAndNotPaused && this._rand.Next(60) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (tileX * 16), (float) (tileY * 16)), 16, 16, 204, Alpha: 150, Scale: 0.3f);
|
|
this._dust[index].fadeIn = 1f;
|
|
this._dust[index].velocity *= 0.1f;
|
|
this._dust[index].noLight = true;
|
|
}
|
|
}
|
|
if (this._isActiveAndNotPaused)
|
|
{
|
|
if (!Lighting.UpdateEveryFrame || new FastRandom(Main.TileFrameSeed).WithModifier(tileX, tileY).Next(4) == 0)
|
|
this.DrawTiles_EmitParticles(tileY, tileX, drawData.tileCache, drawData.typeCache, drawData.tileFrameX, drawData.tileFrameY, drawData.tileLight);
|
|
drawData.tileLight = this.DrawTiles_GetLightOverride(tileY, tileX, drawData.tileCache, drawData.typeCache, drawData.tileFrameX, drawData.tileFrameY, drawData.tileLight);
|
|
}
|
|
this.CacheSpecialDraws(tileX, tileY, drawData);
|
|
if (drawData.typeCache == (ushort) 72 && drawData.tileFrameX >= (short) 36)
|
|
{
|
|
int num = 0;
|
|
if (drawData.tileFrameY == (short) 18)
|
|
num = 1;
|
|
else if (drawData.tileFrameY == (short) 36)
|
|
num = 2;
|
|
Main.spriteBatch.Draw(TextureAssets.ShroomCap.Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X - 22), (float) (tileY * 16 - (int) screenPosition.Y - 26)) + screenOffset, new Rectangle?(new Rectangle(num * 62, 0, 60, 42)), Lighting.GetColor(tileX, tileY), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
Rectangle normalTileRect = new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight - drawData.halfBrickHeight);
|
|
Vector2 vector2 = new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop + drawData.halfBrickHeight)) + screenOffset;
|
|
if (drawData.tileLight.R < (byte) 1 && drawData.tileLight.G < (byte) 1 && drawData.tileLight.B < (byte) 1)
|
|
return;
|
|
this.DrawTile_LiquidBehindTile(solidLayer, waterStyleOverride, screenPosition, screenOffset, tileX, tileY, drawData);
|
|
drawData.colorTint = Color.White;
|
|
drawData.finalColor = TileDrawing.GetFinalLight(drawData.tileCache, drawData.typeCache, drawData.tileLight, drawData.colorTint);
|
|
switch (drawData.typeCache)
|
|
{
|
|
case 51:
|
|
drawData.finalColor = drawData.tileLight * 0.5f;
|
|
break;
|
|
case 80:
|
|
bool evil;
|
|
bool good;
|
|
bool crimson;
|
|
this.GetCactusType(tileX, tileY, (int) drawData.tileFrameX, (int) drawData.tileFrameY, out evil, out good, out crimson);
|
|
if (evil)
|
|
normalTileRect.Y += 54;
|
|
if (good)
|
|
normalTileRect.Y += 108;
|
|
if (crimson)
|
|
{
|
|
normalTileRect.Y += 162;
|
|
break;
|
|
}
|
|
break;
|
|
case 83:
|
|
drawData.drawTexture = this.GetTileDrawTexture(drawData.tileCache, tileX, tileY);
|
|
break;
|
|
case 129:
|
|
drawData.finalColor = new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, 100);
|
|
int num1 = 2;
|
|
if (drawData.tileFrameX >= (short) 324)
|
|
drawData.finalColor = Color.Transparent;
|
|
if (drawData.tileFrameY < (short) 36)
|
|
{
|
|
vector2.Y += (float) (num1 * (drawData.tileFrameY == (short) 0).ToDirectionInt());
|
|
break;
|
|
}
|
|
vector2.X += (float) (num1 * (drawData.tileFrameY == (short) 36).ToDirectionInt());
|
|
break;
|
|
case 136:
|
|
switch ((int) drawData.tileFrameX / 18)
|
|
{
|
|
case 1:
|
|
vector2.X += -2f;
|
|
break;
|
|
case 2:
|
|
vector2.X += 2f;
|
|
break;
|
|
}
|
|
break;
|
|
case 160:
|
|
Color oldColor = new Color(Main.DiscoR, Main.DiscoG, Main.DiscoB, (int) byte.MaxValue);
|
|
if (drawData.tileCache.inActive())
|
|
oldColor = drawData.tileCache.actColor(oldColor);
|
|
drawData.finalColor = oldColor;
|
|
break;
|
|
case 272:
|
|
int num2 = (Main.tileFrame[(int) drawData.typeCache] + tileX % 2 + tileY % 2 + tileX % 3 + tileY % 3) % 2 * 90;
|
|
drawData.addFrY += num2;
|
|
normalTileRect.Y += num2;
|
|
break;
|
|
case 323:
|
|
if (drawData.tileCache.frameX <= (short) 132 && drawData.tileCache.frameX >= (short) 88)
|
|
return;
|
|
vector2.X += (float) drawData.tileCache.frameY;
|
|
break;
|
|
case 442:
|
|
if ((int) drawData.tileFrameX / 22 == 3)
|
|
{
|
|
vector2.X += 2f;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (drawData.typeCache == (ushort) 314)
|
|
this.DrawTile_MinecartTrack(screenPosition, screenOffset, tileX, tileY, drawData);
|
|
else if (drawData.typeCache == (ushort) 171)
|
|
this.DrawXmasTree(screenPosition, screenOffset, tileX, tileY, drawData);
|
|
else
|
|
this.DrawBasicTile(screenPosition, screenOffset, tileX, tileY, drawData, normalTileRect, vector2);
|
|
if (Main.tileGlowMask[(int) drawData.tileCache.type] != (short) -1)
|
|
{
|
|
short num3 = Main.tileGlowMask[(int) drawData.tileCache.type];
|
|
if (TextureAssets.GlowMask.IndexInRange<Asset<Texture2D>>((int) num3))
|
|
drawData.drawTexture = TextureAssets.GlowMask[(int) num3].Value;
|
|
double num4 = Main.timeForVisualEffects * 0.08;
|
|
Color color = Color.White;
|
|
bool flag = false;
|
|
switch (drawData.tileCache.type)
|
|
{
|
|
case 129:
|
|
if (drawData.tileFrameX < (short) 324)
|
|
{
|
|
flag = true;
|
|
break;
|
|
}
|
|
drawData.drawTexture = this.GetTileDrawTexture(drawData.tileCache, tileX, tileY);
|
|
Color rgb = Main.hslToRgb((float) (0.699999988079071 + Math.Sin(6.28318548202515 * (double) Main.GlobalTimeWrappedHourly * 0.159999996423721 + (double) tileX * 0.300000011920929 + (double) tileY * 0.699999988079071) * 0.159999996423721), 1f, 0.5f);
|
|
rgb.A /= (byte) 2;
|
|
color = rgb * 0.3f;
|
|
int num5 = 72;
|
|
for (float f = 0.0f; (double) f < 6.28318548202515; f += 1.570796f)
|
|
Main.spriteBatch.Draw(drawData.drawTexture, vector2 + f.ToRotationVector2() * 2f, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY + num5, drawData.tileWidth, drawData.tileHeight)), color, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
color = new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, 100);
|
|
break;
|
|
case 209:
|
|
color = PortalHelper.GetPortalColor(Main.myPlayer, drawData.tileCache.frameX >= (short) 288 ? 1 : 0);
|
|
break;
|
|
case 350:
|
|
color = new Color(new Vector4((float) (-Math.Cos((int) (num4 / 6.283) % 3 == 1 ? num4 : 0.0) * 0.2 + 0.2)));
|
|
break;
|
|
case 370:
|
|
case 390:
|
|
color = this._meteorGlow;
|
|
break;
|
|
case 381:
|
|
case 517:
|
|
color = this._lavaMossGlow;
|
|
break;
|
|
case 391:
|
|
color = new Color(250, 250, 250, 200);
|
|
break;
|
|
case 429:
|
|
case 445:
|
|
drawData.drawTexture = this.GetTileDrawTexture(drawData.tileCache, tileX, tileY);
|
|
drawData.addFrY = 18;
|
|
break;
|
|
case 534:
|
|
case 535:
|
|
color = this._kryptonMossGlow;
|
|
break;
|
|
case 536:
|
|
case 537:
|
|
color = this._xenonMossGlow;
|
|
break;
|
|
case 539:
|
|
case 540:
|
|
color = this._argonMossGlow;
|
|
break;
|
|
}
|
|
if (!flag)
|
|
{
|
|
if (drawData.tileCache.slope() == (byte) 0 && !drawData.tileCache.halfBrick())
|
|
Main.spriteBatch.Draw(drawData.drawTexture, vector2, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), color, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
else if (drawData.tileCache.halfBrick())
|
|
{
|
|
Main.spriteBatch.Draw(drawData.drawTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + 10)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY + 10, drawData.tileWidth, 6)), color, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
else
|
|
{
|
|
byte num6 = drawData.tileCache.slope();
|
|
for (int index = 0; index < 8; ++index)
|
|
{
|
|
int width = index << 1;
|
|
Rectangle rectangle2 = new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY + index * 2, width, 2);
|
|
int num7 = 0;
|
|
switch (num6)
|
|
{
|
|
case 2:
|
|
rectangle2.X = 16 - width;
|
|
num7 = 16 - width;
|
|
break;
|
|
case 3:
|
|
rectangle2.Width = 16 - width;
|
|
break;
|
|
case 4:
|
|
rectangle2.Width = 14 - width;
|
|
rectangle2.X = width + 2;
|
|
num7 = width + 2;
|
|
break;
|
|
}
|
|
Main.spriteBatch.Draw(drawData.drawTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + (float) num7, (float) (tileY * 16 - (int) screenPosition.Y + index * 2)) + screenOffset, new Rectangle?(rectangle2), color, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (drawData.glowTexture != null)
|
|
{
|
|
Vector2 position = new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset;
|
|
if (TileID.Sets.Platforms[(int) drawData.typeCache])
|
|
position = vector2;
|
|
Main.spriteBatch.Draw(drawData.glowTexture, position, new Rectangle?(drawData.glowSourceRect), drawData.glowColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
if (highlightTexture == null)
|
|
return;
|
|
rectangle1 = new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight);
|
|
int num8 = 0;
|
|
int num9 = 0;
|
|
Main.spriteBatch.Draw(highlightTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + (float) num8, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop + num9)) + screenOffset, new Rectangle?(rectangle1), transparent, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
|
|
private Texture2D GetTileDrawTexture(Tile tile, int tileX, int tileY)
|
|
{
|
|
Texture2D texture2D = TextureAssets.Tile[(int) tile.type].Value;
|
|
int tileStyle = 0;
|
|
int num = (int) tile.type;
|
|
switch (tile.type)
|
|
{
|
|
case 5:
|
|
tileStyle = TileDrawing.GetTreeBiome(tileX, tileY, (int) tile.frameX, (int) tile.frameY);
|
|
break;
|
|
case 83:
|
|
if (this.IsAlchemyPlantHarvestable((int) tile.frameX / 18))
|
|
num = 84;
|
|
Main.instance.LoadTiles(num);
|
|
break;
|
|
case 323:
|
|
tileStyle = this.GetPalmTreeBiome(tileX, tileY);
|
|
break;
|
|
}
|
|
Texture2D requestIfNotReady = this._paintSystem.TryGetTileAndRequestIfNotReady(num, tileStyle, (int) tile.color());
|
|
if (requestIfNotReady != null)
|
|
texture2D = requestIfNotReady;
|
|
return texture2D;
|
|
}
|
|
|
|
private Texture2D GetTileDrawTexture(
|
|
Tile tile,
|
|
int tileX,
|
|
int tileY,
|
|
int paintOverride)
|
|
{
|
|
Texture2D texture2D = TextureAssets.Tile[(int) tile.type].Value;
|
|
int tileStyle = 0;
|
|
int num = (int) tile.type;
|
|
switch (tile.type)
|
|
{
|
|
case 5:
|
|
tileStyle = TileDrawing.GetTreeBiome(tileX, tileY, (int) tile.frameX, (int) tile.frameY);
|
|
break;
|
|
case 83:
|
|
if (this.IsAlchemyPlantHarvestable((int) tile.frameX / 18))
|
|
num = 84;
|
|
Main.instance.LoadTiles(num);
|
|
break;
|
|
case 323:
|
|
tileStyle = this.GetPalmTreeBiome(tileX, tileY);
|
|
break;
|
|
}
|
|
Texture2D requestIfNotReady = this._paintSystem.TryGetTileAndRequestIfNotReady(num, tileStyle, paintOverride);
|
|
if (requestIfNotReady != null)
|
|
texture2D = requestIfNotReady;
|
|
return texture2D;
|
|
}
|
|
|
|
private void DrawBasicTile(
|
|
Vector2 screenPosition,
|
|
Vector2 screenOffset,
|
|
int tileX,
|
|
int tileY,
|
|
TileDrawInfo drawData,
|
|
Rectangle normalTileRect,
|
|
Vector2 normalTilePosition)
|
|
{
|
|
if (drawData.tileCache.slope() > (byte) 0)
|
|
{
|
|
if (TileID.Sets.Platforms[(int) drawData.tileCache.type])
|
|
{
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition, new Rectangle?(normalTileRect), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.tileCache.slope() == (byte) 1 && Main.tile[tileX + 1, tileY + 1].active() && Main.tileSolid[(int) Main.tile[tileX + 1, tileY + 1].type] && Main.tile[tileX + 1, tileY + 1].slope() != (byte) 2 && !Main.tile[tileX + 1, tileY + 1].halfBrick() && (!Main.tile[tileX, tileY + 1].active() || Main.tile[tileX, tileY + 1].blockType() != 0 && Main.tile[tileX, tileY + 1].blockType() != 5 || !TileID.Sets.BlocksStairs[(int) Main.tile[tileX, tileY + 1].type] && !TileID.Sets.BlocksStairsAbove[(int) Main.tile[tileX, tileY + 1].type]))
|
|
{
|
|
Rectangle rectangle = new Rectangle(198, (int) drawData.tileFrameY, 16, 16);
|
|
if (TileID.Sets.Platforms[(int) Main.tile[tileX + 1, tileY + 1].type] && Main.tile[tileX + 1, tileY + 1].slope() == (byte) 0)
|
|
rectangle.X = 324;
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2(0.0f, 16f), new Rectangle?(rectangle), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
else
|
|
{
|
|
if (drawData.tileCache.slope() != (byte) 2 || !Main.tile[tileX - 1, tileY + 1].active() || !Main.tileSolid[(int) Main.tile[tileX - 1, tileY + 1].type] || Main.tile[tileX - 1, tileY + 1].slope() == (byte) 1 || Main.tile[tileX - 1, tileY + 1].halfBrick() || Main.tile[tileX, tileY + 1].active() && (Main.tile[tileX, tileY + 1].blockType() == 0 || Main.tile[tileX, tileY + 1].blockType() == 4) && (TileID.Sets.BlocksStairs[(int) Main.tile[tileX, tileY + 1].type] || TileID.Sets.BlocksStairsAbove[(int) Main.tile[tileX, tileY + 1].type]))
|
|
return;
|
|
Rectangle rectangle = new Rectangle(162, (int) drawData.tileFrameY, 16, 16);
|
|
if (TileID.Sets.Platforms[(int) Main.tile[tileX - 1, tileY + 1].type] && Main.tile[tileX - 1, tileY + 1].slope() == (byte) 0)
|
|
rectangle.X = 306;
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2(0.0f, 16f), new Rectangle?(rectangle), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
else if (TileID.Sets.HasSlopeFrames[(int) drawData.tileCache.type])
|
|
{
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, 16, 16)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
else
|
|
{
|
|
int num1 = (int) drawData.tileCache.slope();
|
|
int width = 2;
|
|
for (int index = 0; index < 8; ++index)
|
|
{
|
|
int num2 = index * -2;
|
|
int height = 16 - index * 2;
|
|
int num3 = 16 - height;
|
|
int num4;
|
|
switch (num1)
|
|
{
|
|
case 1:
|
|
num2 = 0;
|
|
num4 = index * 2;
|
|
height = 14 - index * 2;
|
|
num3 = 0;
|
|
break;
|
|
case 2:
|
|
num2 = 0;
|
|
num4 = 16 - index * 2 - 2;
|
|
height = 14 - index * 2;
|
|
num3 = 0;
|
|
break;
|
|
case 3:
|
|
num4 = index * 2;
|
|
break;
|
|
default:
|
|
num4 = 16 - index * 2 - 2;
|
|
break;
|
|
}
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2((float) num4, (float) (index * width + num2)), new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX + num4, (int) drawData.tileFrameY + drawData.addFrY + num3, width, height)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
int num5 = num1 > 2 ? 0 : 14;
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2(0.0f, (float) num5), new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY + num5, 16, 2)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
else if (!TileID.Sets.Platforms[(int) drawData.typeCache] && !TileID.Sets.IgnoresNearbyHalfbricksWhenDrawn[(int) drawData.typeCache] && this._tileSolid[(int) drawData.typeCache] && !TileID.Sets.NotReallySolid[(int) drawData.typeCache] && !drawData.tileCache.halfBrick() && (Main.tile[tileX - 1, tileY].halfBrick() || Main.tile[tileX + 1, tileY].halfBrick()))
|
|
{
|
|
if (Main.tile[tileX - 1, tileY].halfBrick() && Main.tile[tileX + 1, tileY].halfBrick())
|
|
{
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2(0.0f, 8f), new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, drawData.addFrY + (int) drawData.tileFrameY + 8, drawData.tileWidth, 8)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
Rectangle rectangle = new Rectangle(126 + drawData.addFrX, drawData.addFrY, 16, 8);
|
|
if (Main.tile[tileX, tileY - 1].active() && !Main.tile[tileX, tileY - 1].bottomSlope() && (int) Main.tile[tileX, tileY - 1].type == (int) drawData.typeCache)
|
|
rectangle = new Rectangle(90 + drawData.addFrX, drawData.addFrY, 16, 8);
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition, new Rectangle?(rectangle), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
else if (Main.tile[tileX - 1, tileY].halfBrick())
|
|
{
|
|
int width = 4;
|
|
if (TileID.Sets.AllBlocksWithSmoothBordersToResolveHalfBlockIssue[(int) drawData.typeCache])
|
|
width = 2;
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2(0.0f, 8f), new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, drawData.addFrY + (int) drawData.tileFrameY + 8, drawData.tileWidth, 8)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2((float) width, 0.0f), new Rectangle?(new Rectangle((int) drawData.tileFrameX + width + drawData.addFrX, drawData.addFrY + (int) drawData.tileFrameY, drawData.tileWidth - width, drawData.tileHeight)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition, new Rectangle?(new Rectangle(144 + drawData.addFrX, drawData.addFrY, width, 8)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (width != 2)
|
|
return;
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition, new Rectangle?(new Rectangle(148 + drawData.addFrX, drawData.addFrY, 2, 2)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
else
|
|
{
|
|
if (!Main.tile[tileX + 1, tileY].halfBrick())
|
|
return;
|
|
int width = 4;
|
|
if (TileID.Sets.AllBlocksWithSmoothBordersToResolveHalfBlockIssue[(int) drawData.typeCache])
|
|
width = 2;
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2(0.0f, 8f), new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, drawData.addFrY + (int) drawData.tileFrameY + 8, drawData.tileWidth, 8)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, drawData.addFrY + (int) drawData.tileFrameY, drawData.tileWidth - width, drawData.tileHeight)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2((float) (16 - width), 0.0f), new Rectangle?(new Rectangle(144 + (16 - width), 0, width, 8)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (width != 2)
|
|
return;
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2(14f, 0.0f), new Rectangle?(new Rectangle(156, 0, 2, 2)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
else if (Lighting.NotRetro && this._tileSolid[(int) drawData.typeCache] && !drawData.tileCache.halfBrick() && !drawData.tileCache.inActive() && drawData.typeCache != (ushort) 137 && drawData.typeCache != (ushort) 235 && drawData.typeCache != (ushort) 388 && drawData.typeCache != (ushort) 476 && drawData.typeCache != (ushort) 160 && drawData.typeCache != (ushort) 138)
|
|
{
|
|
this.DrawSingleTile_SlicedBlock(normalTilePosition, tileX, tileY, drawData);
|
|
}
|
|
else
|
|
{
|
|
if (drawData.halfBrickHeight == 8 && (!Main.tile[tileX, tileY + 1].active() || !this._tileSolid[(int) Main.tile[tileX, tileY + 1].type] || Main.tile[tileX, tileY + 1].halfBrick()))
|
|
{
|
|
if (TileID.Sets.Platforms[(int) drawData.typeCache])
|
|
{
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition, new Rectangle?(normalTileRect), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
else
|
|
{
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition, new Rectangle?(normalTileRect.Modified(0, 0, 0, -4)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition + new Vector2(0.0f, 4f), new Rectangle?(new Rectangle(144 + drawData.addFrX, 66 + drawData.addFrY, drawData.tileWidth, 4)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
else
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition, new Rectangle?(normalTileRect), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
this.DrawSingleTile_Flames(screenPosition, screenOffset, tileX, tileY, drawData);
|
|
}
|
|
}
|
|
|
|
private int GetPalmTreeBiome(int tileX, int tileY)
|
|
{
|
|
int x = tileX;
|
|
int y = tileY;
|
|
while (Main.tile[x, y].active() && Main.tile[x, y].type == (ushort) 323)
|
|
++y;
|
|
return this.GetPalmTreeVariant(x, y);
|
|
}
|
|
|
|
private static int GetTreeBiome(int tileX, int tileY, int tileFrameX, int tileFrameY)
|
|
{
|
|
int x = tileX;
|
|
int y = tileY;
|
|
int type = (int) Main.tile[x, y].type;
|
|
if (tileFrameX == 66 && tileFrameY <= 45)
|
|
++x;
|
|
if (tileFrameX == 88 && tileFrameY >= 66 && tileFrameY <= 110)
|
|
--x;
|
|
if (tileFrameY >= 198)
|
|
{
|
|
switch (tileFrameX)
|
|
{
|
|
case 44:
|
|
++x;
|
|
break;
|
|
case 66:
|
|
--x;
|
|
break;
|
|
}
|
|
}
|
|
else if (tileFrameY >= 132)
|
|
{
|
|
switch (tileFrameX)
|
|
{
|
|
case 22:
|
|
--x;
|
|
break;
|
|
case 44:
|
|
++x;
|
|
break;
|
|
}
|
|
}
|
|
while (Main.tile[x, y].active() && (int) Main.tile[x, y].type == type)
|
|
++y;
|
|
return TileDrawing.GetTreeVariant(x, y);
|
|
}
|
|
|
|
public static int GetTreeVariant(int x, int y)
|
|
{
|
|
if (Main.tile[x, y] == null || !Main.tile[x, y].active())
|
|
return -1;
|
|
switch (Main.tile[x, y].type)
|
|
{
|
|
case 23:
|
|
return 0;
|
|
case 60:
|
|
return (double) y <= Main.worldSurface ? 1 : 5;
|
|
case 70:
|
|
return 6;
|
|
case 109:
|
|
case 492:
|
|
return 2;
|
|
case 147:
|
|
return 3;
|
|
case 199:
|
|
return 4;
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
private TileDrawing.TileFlameData GetTileFlameData(
|
|
int tileX,
|
|
int tileY,
|
|
int type,
|
|
int tileFrameY)
|
|
{
|
|
switch (type)
|
|
{
|
|
case 270:
|
|
return new TileDrawing.TileFlameData()
|
|
{
|
|
flameTexture = TextureAssets.FireflyJar.Value,
|
|
flameColor = new Color(200, 200, 200, 0),
|
|
flameCount = 1
|
|
};
|
|
case 271:
|
|
return new TileDrawing.TileFlameData()
|
|
{
|
|
flameTexture = TextureAssets.LightningbugJar.Value,
|
|
flameColor = new Color(200, 200, 200, 0),
|
|
flameCount = 1
|
|
};
|
|
case 581:
|
|
return new TileDrawing.TileFlameData()
|
|
{
|
|
flameTexture = TextureAssets.GlowMask[291].Value,
|
|
flameColor = new Color(200, 100, 100, 0),
|
|
flameCount = 1
|
|
};
|
|
default:
|
|
if (!Main.tileFlame[type])
|
|
return new TileDrawing.TileFlameData();
|
|
ulong num = Main.TileFrameSeed ^ ((ulong) tileX << 32 | (ulong) (uint) tileY);
|
|
int index = 0;
|
|
switch (type)
|
|
{
|
|
case 4:
|
|
index = 0;
|
|
break;
|
|
case 33:
|
|
case 174:
|
|
index = 1;
|
|
break;
|
|
case 34:
|
|
index = 3;
|
|
break;
|
|
case 35:
|
|
index = 7;
|
|
break;
|
|
case 42:
|
|
index = 13;
|
|
break;
|
|
case 49:
|
|
index = 5;
|
|
break;
|
|
case 93:
|
|
index = 4;
|
|
break;
|
|
case 98:
|
|
index = 6;
|
|
break;
|
|
case 100:
|
|
case 173:
|
|
index = 2;
|
|
break;
|
|
case 372:
|
|
index = 16;
|
|
break;
|
|
}
|
|
TileDrawing.TileFlameData tileFlameData = new TileDrawing.TileFlameData()
|
|
{
|
|
flameTexture = TextureAssets.Flames[index].Value,
|
|
flameSeed = num
|
|
};
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
switch ((int) Main.tile[tileX, tileY].frameY / 22)
|
|
{
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 10:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.075f;
|
|
tileFlameData.flameRangeMultY = 0.075f;
|
|
break;
|
|
case 8:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.3f;
|
|
tileFlameData.flameRangeMultY = 0.3f;
|
|
break;
|
|
case 12:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.1f;
|
|
tileFlameData.flameRangeMultY = 0.15f;
|
|
break;
|
|
case 14:
|
|
tileFlameData.flameCount = 8;
|
|
tileFlameData.flameColor = new Color(75, 75, 75, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.1f;
|
|
tileFlameData.flameRangeMultY = 0.1f;
|
|
break;
|
|
case 16:
|
|
tileFlameData.flameCount = 4;
|
|
tileFlameData.flameColor = new Color(75, 75, 75, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.15f;
|
|
break;
|
|
case 27:
|
|
case 28:
|
|
tileFlameData.flameCount = 1;
|
|
tileFlameData.flameColor = new Color(75, 75, 75, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.0f;
|
|
tileFlameData.flameRangeMultY = 0.0f;
|
|
break;
|
|
default:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(100, 100, 100, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.35f;
|
|
break;
|
|
}
|
|
break;
|
|
case 2:
|
|
switch ((int) Main.tile[tileX, tileY].frameY / 36)
|
|
{
|
|
case 3:
|
|
tileFlameData.flameCount = 3;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.05f;
|
|
tileFlameData.flameRangeMultY = 0.15f;
|
|
break;
|
|
case 6:
|
|
tileFlameData.flameCount = 5;
|
|
tileFlameData.flameColor = new Color(75, 75, 75, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.15f;
|
|
break;
|
|
case 9:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(100, 100, 100, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.3f;
|
|
tileFlameData.flameRangeMultY = 0.3f;
|
|
break;
|
|
case 11:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.1f;
|
|
tileFlameData.flameRangeMultY = 0.15f;
|
|
break;
|
|
case 13:
|
|
tileFlameData.flameCount = 8;
|
|
tileFlameData.flameColor = new Color(75, 75, 75, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.1f;
|
|
tileFlameData.flameRangeMultY = 0.1f;
|
|
break;
|
|
case 28:
|
|
case 29:
|
|
tileFlameData.flameCount = 1;
|
|
tileFlameData.flameColor = new Color(75, 75, 75, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.0f;
|
|
tileFlameData.flameRangeMultY = 0.0f;
|
|
break;
|
|
default:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(100, 100, 100, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.35f;
|
|
break;
|
|
}
|
|
break;
|
|
case 3:
|
|
switch ((int) Main.tile[tileX, tileY].frameY / 54)
|
|
{
|
|
case 8:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.075f;
|
|
tileFlameData.flameRangeMultY = 0.075f;
|
|
break;
|
|
case 9:
|
|
tileFlameData.flameCount = 3;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.05f;
|
|
tileFlameData.flameRangeMultY = 0.15f;
|
|
break;
|
|
case 11:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.3f;
|
|
tileFlameData.flameRangeMultY = 0.3f;
|
|
break;
|
|
case 15:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.1f;
|
|
tileFlameData.flameRangeMultY = 0.15f;
|
|
break;
|
|
case 17:
|
|
case 20:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.075f;
|
|
tileFlameData.flameRangeMultY = 0.075f;
|
|
break;
|
|
case 18:
|
|
tileFlameData.flameCount = 8;
|
|
tileFlameData.flameColor = new Color(75, 75, 75, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.1f;
|
|
tileFlameData.flameRangeMultY = 0.1f;
|
|
break;
|
|
case 34:
|
|
case 35:
|
|
tileFlameData.flameCount = 1;
|
|
tileFlameData.flameColor = new Color(75, 75, 75, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.0f;
|
|
tileFlameData.flameRangeMultY = 0.0f;
|
|
break;
|
|
default:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(100, 100, 100, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.35f;
|
|
break;
|
|
}
|
|
break;
|
|
case 4:
|
|
switch ((int) Main.tile[tileX, tileY].frameY / 54)
|
|
{
|
|
case 1:
|
|
tileFlameData.flameCount = 3;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.15f;
|
|
break;
|
|
case 2:
|
|
case 4:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.075f;
|
|
tileFlameData.flameRangeMultY = 0.075f;
|
|
break;
|
|
case 3:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(100, 100, 100, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -20;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.2f;
|
|
tileFlameData.flameRangeMultY = 0.35f;
|
|
break;
|
|
case 5:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.3f;
|
|
tileFlameData.flameRangeMultY = 0.3f;
|
|
break;
|
|
case 9:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.1f;
|
|
tileFlameData.flameRangeMultY = 0.15f;
|
|
break;
|
|
case 12:
|
|
tileFlameData.flameCount = 1;
|
|
tileFlameData.flameColor = new Color(100, 100, 100, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.01f;
|
|
tileFlameData.flameRangeMultY = 0.01f;
|
|
break;
|
|
case 13:
|
|
tileFlameData.flameCount = 8;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.1f;
|
|
tileFlameData.flameRangeMultY = 0.1f;
|
|
break;
|
|
case 28:
|
|
case 29:
|
|
tileFlameData.flameCount = 1;
|
|
tileFlameData.flameColor = new Color(75, 75, 75, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.0f;
|
|
tileFlameData.flameRangeMultY = 0.0f;
|
|
break;
|
|
default:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(100, 100, 100, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.35f;
|
|
break;
|
|
}
|
|
break;
|
|
case 7:
|
|
tileFlameData.flameCount = 4;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 10;
|
|
tileFlameData.flameRangeMultX = 0.0f;
|
|
tileFlameData.flameRangeMultY = 0.0f;
|
|
break;
|
|
case 13:
|
|
switch (tileFrameY / 36)
|
|
{
|
|
case 1:
|
|
case 3:
|
|
case 6:
|
|
case 8:
|
|
case 19:
|
|
case 27:
|
|
case 29:
|
|
case 30:
|
|
case 31:
|
|
case 32:
|
|
case 36:
|
|
case 39:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(100, 100, 100, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.35f;
|
|
break;
|
|
case 2:
|
|
case 16:
|
|
case 25:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.1f;
|
|
break;
|
|
case 11:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(50, 50, 50, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 11;
|
|
tileFlameData.flameRangeMultX = 0.075f;
|
|
tileFlameData.flameRangeMultY = 0.075f;
|
|
break;
|
|
case 34:
|
|
case 35:
|
|
tileFlameData.flameCount = 1;
|
|
tileFlameData.flameColor = new Color(75, 75, 75, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.0f;
|
|
tileFlameData.flameRangeMultY = 0.0f;
|
|
break;
|
|
case 44:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(100, 100, 100, 0);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.35f;
|
|
break;
|
|
default:
|
|
tileFlameData.flameCount = 0;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
tileFlameData.flameCount = 7;
|
|
tileFlameData.flameColor = new Color(100, 100, 100, 0);
|
|
if (tileFrameY / 22 == 14)
|
|
tileFlameData.flameColor = new Color((float) Main.DiscoR / (float) byte.MaxValue, (float) Main.DiscoG / (float) byte.MaxValue, (float) Main.DiscoB / (float) byte.MaxValue, 0.0f);
|
|
tileFlameData.flameRangeXMin = -10;
|
|
tileFlameData.flameRangeXMax = 11;
|
|
tileFlameData.flameRangeYMin = -10;
|
|
tileFlameData.flameRangeYMax = 1;
|
|
tileFlameData.flameRangeMultX = 0.15f;
|
|
tileFlameData.flameRangeMultY = 0.35f;
|
|
break;
|
|
}
|
|
return tileFlameData;
|
|
}
|
|
}
|
|
|
|
private void DrawSingleTile_Flames(
|
|
Vector2 screenPosition,
|
|
Vector2 screenOffset,
|
|
int tileX,
|
|
int tileY,
|
|
TileDrawInfo drawData)
|
|
{
|
|
if (drawData.typeCache == (ushort) 548 && (int) drawData.tileFrameX / 54 > 6)
|
|
Main.spriteBatch.Draw(TextureAssets.GlowMask[297].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), Color.White, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 613)
|
|
Main.spriteBatch.Draw(TextureAssets.GlowMask[298].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), Color.White, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 614)
|
|
Main.spriteBatch.Draw(TextureAssets.GlowMask[299].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), Color.White, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 593)
|
|
Main.spriteBatch.Draw(TextureAssets.GlowMask[295].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), Color.White, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 594)
|
|
Main.spriteBatch.Draw(TextureAssets.GlowMask[296].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), Color.White, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 215 && drawData.tileFrameY < (short) 36)
|
|
{
|
|
int index = 15;
|
|
Color color = new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, 0);
|
|
if ((int) drawData.tileFrameX / 54 == 5)
|
|
color = new Color((float) Main.DiscoR / (float) byte.MaxValue, (float) Main.DiscoG / (float) byte.MaxValue, (float) Main.DiscoB / (float) byte.MaxValue, 0.0f);
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), color, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
if (drawData.typeCache == (ushort) 85)
|
|
{
|
|
float graveyardVisualIntensity = Main.GraveyardVisualIntensity;
|
|
if ((double) graveyardVisualIntensity > 0.0)
|
|
{
|
|
ulong num1 = Main.TileFrameSeed ^ ((ulong) tileX << 32 | (ulong) (uint) tileY);
|
|
TileDrawing.TileFlameData tileFlameData = this.GetTileFlameData(tileX, tileY, (int) drawData.typeCache, (int) drawData.tileFrameY);
|
|
if (num1 == 0UL)
|
|
num1 = tileFlameData.flameSeed;
|
|
tileFlameData.flameSeed = num1;
|
|
Vector2 position = new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset;
|
|
Rectangle rectangle = new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight);
|
|
for (int index = 0; index < tileFlameData.flameCount; ++index)
|
|
{
|
|
Color color = tileFlameData.flameColor * graveyardVisualIntensity;
|
|
float x = (float) Utils.RandomInt(ref tileFlameData.flameSeed, tileFlameData.flameRangeXMin, tileFlameData.flameRangeXMax) * tileFlameData.flameRangeMultX;
|
|
float y = (float) Utils.RandomInt(ref tileFlameData.flameSeed, tileFlameData.flameRangeYMin, tileFlameData.flameRangeYMax) * tileFlameData.flameRangeMultY;
|
|
for (float num2 = 0.0f; (double) num2 < 1.0; num2 += 0.25f)
|
|
Main.spriteBatch.Draw(tileFlameData.flameTexture, position + new Vector2(x, y) + Vector2.UnitX.RotatedBy((double) num2 * 6.28318548202515) * 2f, new Rectangle?(rectangle), color, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
Main.spriteBatch.Draw(tileFlameData.flameTexture, position, new Rectangle?(rectangle), Color.White * graveyardVisualIntensity, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
if (drawData.typeCache == (ushort) 286)
|
|
Main.spriteBatch.Draw(TextureAssets.GlowSnail.Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 100, (int) byte.MaxValue, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 582)
|
|
Main.spriteBatch.Draw(TextureAssets.GlowMask[293].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), new Color(200, 100, 100, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 391)
|
|
Main.spriteBatch.Draw(TextureAssets.GlowMask[131].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), new Color(250, 250, 250, 200), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 619)
|
|
Main.spriteBatch.Draw(TextureAssets.GlowMask[300].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 100, (int) byte.MaxValue, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 270)
|
|
Main.spriteBatch.Draw(TextureAssets.FireflyJar.Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(200, 200, 200, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 271)
|
|
Main.spriteBatch.Draw(TextureAssets.LightningbugJar.Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(200, 200, 200, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 581)
|
|
Main.spriteBatch.Draw(TextureAssets.GlowMask[291].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(200, 200, 200, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 316 || drawData.typeCache == (ushort) 317 || drawData.typeCache == (ushort) 318)
|
|
{
|
|
int index = (tileX - (int) drawData.tileFrameX / 18) / 2 * ((tileY - (int) drawData.tileFrameY / 18) / 3) % Main.cageFrames;
|
|
Main.spriteBatch.Draw(TextureAssets.JellyfishBowl[(int) drawData.typeCache - 316].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + Main.jellyfishCageFrame[(int) drawData.typeCache - 316, index] * 36, drawData.tileWidth, drawData.tileHeight)), new Color(200, 200, 200, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
if (drawData.typeCache == (ushort) 149 && drawData.tileFrameX < (short) 54)
|
|
Main.spriteBatch.Draw(TextureAssets.XmasLight.Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(200, 200, 200, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache == (ushort) 300 || drawData.typeCache == (ushort) 302 || drawData.typeCache == (ushort) 303 || drawData.typeCache == (ushort) 306)
|
|
{
|
|
int index = 9;
|
|
if (drawData.typeCache == (ushort) 302)
|
|
index = 10;
|
|
if (drawData.typeCache == (ushort) 303)
|
|
index = 11;
|
|
if (drawData.typeCache == (ushort) 306)
|
|
index = 12;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), new Color(200, 200, 200, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
else if (Main.tileFlame[(int) drawData.typeCache])
|
|
{
|
|
ulong seed = Main.TileFrameSeed ^ ((ulong) tileX << 32 | (ulong) (uint) tileY);
|
|
int typeCache = (int) drawData.typeCache;
|
|
int index1 = 0;
|
|
switch (typeCache)
|
|
{
|
|
case 4:
|
|
index1 = 0;
|
|
break;
|
|
case 33:
|
|
case 174:
|
|
index1 = 1;
|
|
break;
|
|
case 34:
|
|
index1 = 3;
|
|
break;
|
|
case 35:
|
|
index1 = 7;
|
|
break;
|
|
case 42:
|
|
index1 = 13;
|
|
break;
|
|
case 49:
|
|
index1 = 5;
|
|
break;
|
|
case 93:
|
|
index1 = 4;
|
|
break;
|
|
case 98:
|
|
index1 = 6;
|
|
break;
|
|
case 100:
|
|
case 173:
|
|
index1 = 2;
|
|
break;
|
|
case 372:
|
|
index1 = 16;
|
|
break;
|
|
}
|
|
switch (index1)
|
|
{
|
|
case 1:
|
|
switch ((int) Main.tile[tileX, tileY].frameY / 22)
|
|
{
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 10:
|
|
for (int index2 = 0; index2 < 7; ++index2)
|
|
{
|
|
float num3 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.075f;
|
|
float num4 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.075f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num3, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num4) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 8:
|
|
for (int index3 = 0; index3 < 7; ++index3)
|
|
{
|
|
float num5 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.3f;
|
|
float num6 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.3f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num5, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num6) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 12:
|
|
for (int index4 = 0; index4 < 7; ++index4)
|
|
{
|
|
float num7 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
float num8 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.15f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num7, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num8) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 14:
|
|
for (int index5 = 0; index5 < 8; ++index5)
|
|
{
|
|
float num9 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
float num10 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num9, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num10) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 16:
|
|
for (int index6 = 0; index6 < 4; ++index6)
|
|
{
|
|
float num11 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num12 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num11, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num12) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 27:
|
|
case 28:
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
break;
|
|
default:
|
|
for (int index7 = 0; index7 < 7; ++index7)
|
|
{
|
|
float num13 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num14 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.35f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num13, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num14) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(100, 100, 100, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case 2:
|
|
switch ((int) Main.tile[tileX, tileY].frameY / 36)
|
|
{
|
|
case 3:
|
|
for (int index8 = 0; index8 < 3; ++index8)
|
|
{
|
|
float num15 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.05f;
|
|
float num16 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num15, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num16) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 6:
|
|
for (int index9 = 0; index9 < 5; ++index9)
|
|
{
|
|
float num17 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num18 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num17, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num18) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 9:
|
|
for (int index10 = 0; index10 < 7; ++index10)
|
|
{
|
|
float num19 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.3f;
|
|
float num20 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.3f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num19, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num20) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(100, 100, 100, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 11:
|
|
for (int index11 = 0; index11 < 7; ++index11)
|
|
{
|
|
float num21 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
float num22 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.15f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num21, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num22) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 13:
|
|
for (int index12 = 0; index12 < 8; ++index12)
|
|
{
|
|
float num23 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
float num24 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num23, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num24) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 28:
|
|
case 29:
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
break;
|
|
default:
|
|
for (int index13 = 0; index13 < 7; ++index13)
|
|
{
|
|
float num25 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num26 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.35f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num25, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num26) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(100, 100, 100, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case 3:
|
|
switch ((int) Main.tile[tileX, tileY].frameY / 54)
|
|
{
|
|
case 8:
|
|
for (int index14 = 0; index14 < 7; ++index14)
|
|
{
|
|
float num27 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.075f;
|
|
float num28 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.075f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num27, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num28) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 9:
|
|
for (int index15 = 0; index15 < 3; ++index15)
|
|
{
|
|
float num29 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.05f;
|
|
float num30 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num29, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num30) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 11:
|
|
for (int index16 = 0; index16 < 7; ++index16)
|
|
{
|
|
float num31 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.3f;
|
|
float num32 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.3f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num31, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num32) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 15:
|
|
for (int index17 = 0; index17 < 7; ++index17)
|
|
{
|
|
float num33 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
float num34 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.15f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num33, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num34) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 17:
|
|
case 20:
|
|
for (int index18 = 0; index18 < 7; ++index18)
|
|
{
|
|
float num35 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.075f;
|
|
float num36 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.075f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num35, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num36) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 18:
|
|
for (int index19 = 0; index19 < 8; ++index19)
|
|
{
|
|
float num37 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
float num38 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num37, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num38) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 34:
|
|
case 35:
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
break;
|
|
default:
|
|
for (int index20 = 0; index20 < 7; ++index20)
|
|
{
|
|
float num39 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num40 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.35f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num39, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num40) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(100, 100, 100, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case 4:
|
|
switch ((int) Main.tile[tileX, tileY].frameY / 54)
|
|
{
|
|
case 1:
|
|
for (int index21 = 0; index21 < 3; ++index21)
|
|
{
|
|
float num41 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num42 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num41, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num42) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 2:
|
|
case 4:
|
|
for (int index22 = 0; index22 < 7; ++index22)
|
|
{
|
|
float num43 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.075f;
|
|
float num44 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.075f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num43, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num44) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 3:
|
|
for (int index23 = 0; index23 < 7; ++index23)
|
|
{
|
|
float num45 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.2f;
|
|
float num46 = (float) Utils.RandomInt(ref seed, -20, 1) * 0.35f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num45, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num46) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(100, 100, 100, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 5:
|
|
for (int index24 = 0; index24 < 7; ++index24)
|
|
{
|
|
float num47 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.3f;
|
|
float num48 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.3f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num47, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num48) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 9:
|
|
for (int index25 = 0; index25 < 7; ++index25)
|
|
{
|
|
float num49 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
float num50 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.15f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num49, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num50) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 12:
|
|
float num51 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.01f;
|
|
float num52 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.01f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num51, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num52) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(Utils.RandomInt(ref seed, 90, 111), Utils.RandomInt(ref seed, 90, 111), Utils.RandomInt(ref seed, 90, 111), 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
break;
|
|
case 13:
|
|
for (int index26 = 0; index26 < 8; ++index26)
|
|
{
|
|
float num53 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
float num54 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.1f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num53, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num54) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 28:
|
|
case 29:
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
break;
|
|
default:
|
|
for (int index27 = 0; index27 < 7; ++index27)
|
|
{
|
|
float num55 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num56 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.35f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num55, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num56) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), new Color(100, 100, 100, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case 7:
|
|
for (int index28 = 0; index28 < 4; ++index28)
|
|
{
|
|
float num57 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num58 = (float) Utils.RandomInt(ref seed, -10, 10) * 0.15f;
|
|
float num59 = 0.0f;
|
|
float num60 = 0.0f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num59, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num60) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
case 13:
|
|
int num61 = (int) drawData.tileFrameY / 36;
|
|
if (num61 == 1 || num61 == 3 || num61 == 6 || num61 == 8 || num61 == 19 || num61 == 27 || num61 == 29 || num61 == 30 || num61 == 31 || num61 == 32 || num61 == 36 || num61 == 39)
|
|
{
|
|
for (int index29 = 0; index29 < 7; ++index29)
|
|
{
|
|
float num62 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num63 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.35f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num62, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num63) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(100, 100, 100, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
}
|
|
if (num61 == 25 || num61 == 16 || num61 == 2)
|
|
{
|
|
for (int index30 = 0; index30 < 7; ++index30)
|
|
{
|
|
float num64 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num65 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.1f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num64, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num65) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(50, 50, 50, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
}
|
|
if (num61 == 29)
|
|
{
|
|
for (int index31 = 0; index31 < 7; ++index31)
|
|
{
|
|
float num66 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num67 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.15f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num66, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num67) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(25, 25, 25, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
}
|
|
if (num61 == 34 || num61 == 35)
|
|
{
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(75, 75, 75, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
for (int index32 = 0; index32 < 7; ++index32)
|
|
{
|
|
Color color = new Color(100, 100, 100, 0);
|
|
if ((int) drawData.tileFrameY / 22 == 14)
|
|
color = new Color((float) Main.DiscoR / (float) byte.MaxValue, (float) Main.DiscoG / (float) byte.MaxValue, (float) Main.DiscoB / (float) byte.MaxValue, 0.0f);
|
|
float num68 = (float) Utils.RandomInt(ref seed, -10, 11) * 0.15f;
|
|
float num69 = (float) Utils.RandomInt(ref seed, -10, 1) * 0.35f;
|
|
Main.spriteBatch.Draw(TextureAssets.Flames[index1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0) + num68, (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop) + num69) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), color, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (drawData.typeCache == (ushort) 144)
|
|
Main.spriteBatch.Draw(TextureAssets.Timer.Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color(200, 200, 200, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (drawData.typeCache != (ushort) 237)
|
|
return;
|
|
Main.spriteBatch.Draw(TextureAssets.SunAltar.Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle((int) drawData.tileFrameX, (int) drawData.tileFrameY, drawData.tileWidth, drawData.tileHeight)), new Color((int) Main.mouseTextColor / 2, (int) Main.mouseTextColor / 2, (int) Main.mouseTextColor / 2, 0), 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
|
|
private int GetPalmTreeVariant(int x, int y)
|
|
{
|
|
int num = -1;
|
|
if (Main.tile[x, y].active() && Main.tile[x, y].type == (ushort) 53)
|
|
num = 0;
|
|
if (Main.tile[x, y].active() && Main.tile[x, y].type == (ushort) 234)
|
|
num = 1;
|
|
if (Main.tile[x, y].active() && Main.tile[x, y].type == (ushort) 116)
|
|
num = 2;
|
|
if (Main.tile[x, y].active() && Main.tile[x, y].type == (ushort) 112)
|
|
num = 3;
|
|
if (WorldGen.IsPalmOasisTree(x))
|
|
num += 4;
|
|
return num;
|
|
}
|
|
|
|
private void DrawSingleTile_SlicedBlock(
|
|
Vector2 normalTilePosition,
|
|
int tileX,
|
|
int tileY,
|
|
TileDrawInfo drawData)
|
|
{
|
|
Color color = new Color();
|
|
Vector2 origin = new Vector2();
|
|
if ((int) drawData.tileLight.R > (int) this._highQualityLightingRequirement.R || (int) drawData.tileLight.G > (int) this._highQualityLightingRequirement.G || (int) drawData.tileLight.B > (int) this._highQualityLightingRequirement.B)
|
|
{
|
|
Vector3[] slices = drawData.colorSlices;
|
|
Lighting.GetColor9Slice(tileX, tileY, ref slices);
|
|
Vector3 vector3_1 = drawData.tileLight.ToVector3();
|
|
Vector3 vector3_2 = drawData.colorTint.ToVector3();
|
|
if (drawData.tileCache.color() == (byte) 31)
|
|
slices = this._glowPaintColorSlices;
|
|
for (int index = 0; index < 9; ++index)
|
|
{
|
|
Rectangle rectangle;
|
|
rectangle.X = 0;
|
|
rectangle.Y = 0;
|
|
rectangle.Width = 4;
|
|
rectangle.Height = 4;
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
rectangle.Width = 8;
|
|
rectangle.X = 4;
|
|
break;
|
|
case 2:
|
|
rectangle.X = 12;
|
|
break;
|
|
case 3:
|
|
rectangle.Height = 8;
|
|
rectangle.Y = 4;
|
|
break;
|
|
case 4:
|
|
rectangle.Width = 8;
|
|
rectangle.Height = 8;
|
|
rectangle.X = 4;
|
|
rectangle.Y = 4;
|
|
break;
|
|
case 5:
|
|
rectangle.X = 12;
|
|
rectangle.Y = 4;
|
|
rectangle.Height = 8;
|
|
break;
|
|
case 6:
|
|
rectangle.Y = 12;
|
|
break;
|
|
case 7:
|
|
rectangle.Width = 8;
|
|
rectangle.Height = 4;
|
|
rectangle.X = 4;
|
|
rectangle.Y = 12;
|
|
break;
|
|
case 8:
|
|
rectangle.X = 12;
|
|
rectangle.Y = 12;
|
|
break;
|
|
}
|
|
Vector3 tileLight;
|
|
tileLight.X = (float) (((double) slices[index].X + (double) vector3_1.X) * 0.5);
|
|
tileLight.Y = (float) (((double) slices[index].Y + (double) vector3_1.Y) * 0.5);
|
|
tileLight.Z = (float) (((double) slices[index].Z + (double) vector3_1.Z) * 0.5);
|
|
TileDrawing.GetFinalLight(drawData.tileCache, drawData.typeCache, ref tileLight, ref vector3_2);
|
|
Vector2 position;
|
|
position.X = normalTilePosition.X + (float) rectangle.X;
|
|
position.Y = normalTilePosition.Y + (float) rectangle.Y;
|
|
rectangle.X += (int) drawData.tileFrameX + drawData.addFrX;
|
|
rectangle.Y += (int) drawData.tileFrameY + drawData.addFrY;
|
|
int num1 = (int) ((double) tileLight.X * (double) byte.MaxValue);
|
|
int num2 = (int) ((double) tileLight.Y * (double) byte.MaxValue);
|
|
int num3 = (int) ((double) tileLight.Z * (double) byte.MaxValue);
|
|
if (num1 > (int) byte.MaxValue)
|
|
num1 = (int) byte.MaxValue;
|
|
if (num2 > (int) byte.MaxValue)
|
|
num2 = (int) byte.MaxValue;
|
|
if (num3 > (int) byte.MaxValue)
|
|
num3 = (int) byte.MaxValue;
|
|
int num4 = num3 << 16;
|
|
int num5 = num2 << 8;
|
|
color.PackedValue = (uint) (num1 | num5 | num4 | -16777216);
|
|
Main.spriteBatch.Draw(drawData.drawTexture, position, new Rectangle?(rectangle), color, 0.0f, origin, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
else if ((int) drawData.tileLight.R > (int) this._mediumQualityLightingRequirement.R || (int) drawData.tileLight.G > (int) this._mediumQualityLightingRequirement.G || (int) drawData.tileLight.B > (int) this._mediumQualityLightingRequirement.B)
|
|
{
|
|
Vector3[] colorSlices = drawData.colorSlices;
|
|
Lighting.GetColor4Slice(tileX, tileY, ref colorSlices);
|
|
Vector3 vector3_3 = drawData.tileLight.ToVector3();
|
|
Vector3 vector3_4 = drawData.colorTint.ToVector3();
|
|
Rectangle rectangle;
|
|
rectangle.Width = 8;
|
|
rectangle.Height = 8;
|
|
for (int index = 0; index < 4; ++index)
|
|
{
|
|
rectangle.X = 0;
|
|
rectangle.Y = 0;
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
rectangle.X = 8;
|
|
break;
|
|
case 2:
|
|
rectangle.Y = 8;
|
|
break;
|
|
case 3:
|
|
rectangle.X = 8;
|
|
rectangle.Y = 8;
|
|
break;
|
|
}
|
|
Vector3 tileLight;
|
|
tileLight.X = (float) (((double) colorSlices[index].X + (double) vector3_3.X) * 0.5);
|
|
tileLight.Y = (float) (((double) colorSlices[index].Y + (double) vector3_3.Y) * 0.5);
|
|
tileLight.Z = (float) (((double) colorSlices[index].Z + (double) vector3_3.Z) * 0.5);
|
|
TileDrawing.GetFinalLight(drawData.tileCache, drawData.typeCache, ref tileLight, ref vector3_4);
|
|
Vector2 position;
|
|
position.X = normalTilePosition.X + (float) rectangle.X;
|
|
position.Y = normalTilePosition.Y + (float) rectangle.Y;
|
|
rectangle.X += (int) drawData.tileFrameX + drawData.addFrX;
|
|
rectangle.Y += (int) drawData.tileFrameY + drawData.addFrY;
|
|
int num6 = (int) ((double) tileLight.X * (double) byte.MaxValue);
|
|
int num7 = (int) ((double) tileLight.Y * (double) byte.MaxValue);
|
|
int num8 = (int) ((double) tileLight.Z * (double) byte.MaxValue);
|
|
if (num6 > (int) byte.MaxValue)
|
|
num6 = (int) byte.MaxValue;
|
|
if (num7 > (int) byte.MaxValue)
|
|
num7 = (int) byte.MaxValue;
|
|
if (num8 > (int) byte.MaxValue)
|
|
num8 = (int) byte.MaxValue;
|
|
int num9 = num8 << 16;
|
|
int num10 = num7 << 8;
|
|
color.PackedValue = (uint) (num6 | num10 | num9 | -16777216);
|
|
Main.spriteBatch.Draw(drawData.drawTexture, position, new Rectangle?(rectangle), color, 0.0f, origin, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
else
|
|
Main.spriteBatch.Draw(drawData.drawTexture, normalTilePosition, new Rectangle?(new Rectangle((int) drawData.tileFrameX + drawData.addFrX, (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight)), drawData.finalColor, 0.0f, TileDrawing._zero, 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
|
|
private void GetCactusType(
|
|
int tileX,
|
|
int tileY,
|
|
int frameX,
|
|
int frameY,
|
|
out bool evil,
|
|
out bool good,
|
|
out bool crimson)
|
|
{
|
|
evil = false;
|
|
good = false;
|
|
crimson = false;
|
|
int index1 = tileX;
|
|
if (frameX == 36)
|
|
--index1;
|
|
if (frameX == 54)
|
|
++index1;
|
|
if (frameX == 108)
|
|
{
|
|
if (frameY == 18)
|
|
--index1;
|
|
else
|
|
++index1;
|
|
}
|
|
int index2 = tileY;
|
|
bool flag = false;
|
|
if (Main.tile[index1, index2].type == (ushort) 80 && Main.tile[index1, index2].active())
|
|
flag = true;
|
|
while (!Main.tile[index1, index2].active() || !this._tileSolid[(int) Main.tile[index1, index2].type] || !flag)
|
|
{
|
|
if (Main.tile[index1, index2].type == (ushort) 80 && Main.tile[index1, index2].active())
|
|
flag = true;
|
|
++index2;
|
|
if (index2 > tileY + 20)
|
|
break;
|
|
}
|
|
if (Main.tile[index1, index2].type == (ushort) 112)
|
|
evil = true;
|
|
if (Main.tile[index1, index2].type == (ushort) 116)
|
|
good = true;
|
|
if (Main.tile[index1, index2].type != (ushort) 234)
|
|
return;
|
|
crimson = true;
|
|
}
|
|
|
|
private void DrawXmasTree(
|
|
Vector2 screenPosition,
|
|
Vector2 screenOffset,
|
|
int tileX,
|
|
int tileY,
|
|
TileDrawInfo drawData)
|
|
{
|
|
if (tileY - (int) drawData.tileFrameY > 0 && drawData.tileFrameY == (short) 7 && Main.tile[tileX, tileY - (int) drawData.tileFrameY] != null)
|
|
{
|
|
drawData.tileTop -= 16 * (int) drawData.tileFrameY;
|
|
drawData.tileFrameX = Main.tile[tileX, tileY - (int) drawData.tileFrameY].frameX;
|
|
drawData.tileFrameY = Main.tile[tileX, tileY - (int) drawData.tileFrameY].frameY;
|
|
}
|
|
if (drawData.tileFrameX < (short) 10)
|
|
return;
|
|
int num1 = 0;
|
|
if (((int) drawData.tileFrameY & 1) == 1)
|
|
++num1;
|
|
if (((int) drawData.tileFrameY & 2) == 2)
|
|
num1 += 2;
|
|
if (((int) drawData.tileFrameY & 4) == 4)
|
|
num1 += 4;
|
|
int num2 = 0;
|
|
if (((int) drawData.tileFrameY & 8) == 8)
|
|
++num2;
|
|
if (((int) drawData.tileFrameY & 16) == 16)
|
|
num2 += 2;
|
|
if (((int) drawData.tileFrameY & 32) == 32)
|
|
num2 += 4;
|
|
int num3 = 0;
|
|
if (((int) drawData.tileFrameY & 64) == 64)
|
|
++num3;
|
|
if (((int) drawData.tileFrameY & 128) == 128)
|
|
num3 += 2;
|
|
if (((int) drawData.tileFrameY & 256) == 256)
|
|
num3 += 4;
|
|
if (((int) drawData.tileFrameY & 512) == 512)
|
|
num3 += 8;
|
|
int num4 = 0;
|
|
if (((int) drawData.tileFrameY & 1024) == 1024)
|
|
++num4;
|
|
if (((int) drawData.tileFrameY & 2048) == 2048)
|
|
num4 += 2;
|
|
if (((int) drawData.tileFrameY & 4096) == 4096)
|
|
num4 += 4;
|
|
if (((int) drawData.tileFrameY & 8192) == 8192)
|
|
num4 += 8;
|
|
Color color1 = Lighting.GetColor(tileX + 1, tileY - 3);
|
|
Main.spriteBatch.Draw(TextureAssets.XmasTree[0].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle(0, 0, 64, 128)), color1, 0.0f, TileDrawing._zero, 1f, SpriteEffects.None, 0.0f);
|
|
if (num1 > 0)
|
|
{
|
|
int num5 = num1 - 1;
|
|
Color color2 = color1;
|
|
if (num5 != 3)
|
|
color2 = new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue);
|
|
Main.spriteBatch.Draw(TextureAssets.XmasTree[3].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle(66 * num5, 0, 64, 128)), color2, 0.0f, TileDrawing._zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
if (num2 > 0)
|
|
{
|
|
int num6 = num2 - 1;
|
|
Main.spriteBatch.Draw(TextureAssets.XmasTree[1].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle(66 * num6, 0, 64, 128)), color1, 0.0f, TileDrawing._zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
if (num3 > 0)
|
|
{
|
|
int num7 = num3 - 1;
|
|
Main.spriteBatch.Draw(TextureAssets.XmasTree[2].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle(66 * num7, 0, 64, 128)), color1, 0.0f, TileDrawing._zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
if (num4 <= 0)
|
|
return;
|
|
int num8 = num4 - 1;
|
|
Main.spriteBatch.Draw(TextureAssets.XmasTree[4].Value, new Vector2((float) (tileX * 16 - (int) screenPosition.X) - (float) (((double) drawData.tileWidth - 16.0) / 2.0), (float) (tileY * 16 - (int) screenPosition.Y + drawData.tileTop)) + screenOffset, new Rectangle?(new Rectangle(66 * num8, 130 * Main.tileFrame[171], 64, 128)), new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue), 0.0f, TileDrawing._zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
|
|
private void DrawTile_MinecartTrack(
|
|
Vector2 screenPosition,
|
|
Vector2 screenOffset,
|
|
int tileX,
|
|
int tileY,
|
|
TileDrawInfo drawData)
|
|
{
|
|
drawData.tileLight = TileDrawing.GetFinalLight(drawData.tileCache, drawData.typeCache, drawData.tileLight, drawData.colorTint);
|
|
int frontColor;
|
|
int backColor;
|
|
Minecart.TrackColors(tileX, tileY, drawData.tileCache, out frontColor, out backColor);
|
|
drawData.drawTexture = this.GetTileDrawTexture(drawData.tileCache, tileX, tileY, frontColor);
|
|
Texture2D tileDrawTexture = this.GetTileDrawTexture(drawData.tileCache, tileX, tileY, backColor);
|
|
int num = (int) drawData.tileCache.frameNumber();
|
|
if (drawData.tileFrameY != (short) -1)
|
|
Main.spriteBatch.Draw(tileDrawTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X), (float) (tileY * 16 - (int) screenPosition.Y)) + screenOffset, new Rectangle?(Minecart.GetSourceRect((int) drawData.tileFrameY, Main.tileFrame[314])), drawData.tileLight, 0.0f, new Vector2(), 1f, drawData.tileSpriteEffect, 0.0f);
|
|
Main.spriteBatch.Draw(drawData.drawTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X), (float) (tileY * 16 - (int) screenPosition.Y)) + screenOffset, new Rectangle?(Minecart.GetSourceRect((int) drawData.tileFrameX, Main.tileFrame[314])), drawData.tileLight, 0.0f, new Vector2(), 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (Minecart.DrawLeftDecoration((int) drawData.tileFrameY))
|
|
Main.spriteBatch.Draw(tileDrawTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X), (float) ((tileY + 1) * 16 - (int) screenPosition.Y)) + screenOffset, new Rectangle?(Minecart.GetSourceRect(36)), drawData.tileLight, 0.0f, new Vector2(), 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (Minecart.DrawLeftDecoration((int) drawData.tileFrameX))
|
|
Main.spriteBatch.Draw(drawData.drawTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X), (float) ((tileY + 1) * 16 - (int) screenPosition.Y)) + screenOffset, new Rectangle?(Minecart.GetSourceRect(36)), drawData.tileLight, 0.0f, new Vector2(), 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (Minecart.DrawRightDecoration((int) drawData.tileFrameY))
|
|
Main.spriteBatch.Draw(tileDrawTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X), (float) ((tileY + 1) * 16 - (int) screenPosition.Y)) + screenOffset, new Rectangle?(Minecart.GetSourceRect(37, Main.tileFrame[314])), drawData.tileLight, 0.0f, new Vector2(), 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (Minecart.DrawRightDecoration((int) drawData.tileFrameX))
|
|
Main.spriteBatch.Draw(drawData.drawTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X), (float) ((tileY + 1) * 16 - (int) screenPosition.Y)) + screenOffset, new Rectangle?(Minecart.GetSourceRect(37)), drawData.tileLight, 0.0f, new Vector2(), 1f, drawData.tileSpriteEffect, 0.0f);
|
|
if (Minecart.DrawBumper((int) drawData.tileFrameX))
|
|
{
|
|
Main.spriteBatch.Draw(drawData.drawTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X), (float) ((tileY - 1) * 16 - (int) screenPosition.Y)) + screenOffset, new Rectangle?(Minecart.GetSourceRect(39)), drawData.tileLight, 0.0f, new Vector2(), 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
else
|
|
{
|
|
if (!Minecart.DrawBouncyBumper((int) drawData.tileFrameX))
|
|
return;
|
|
Main.spriteBatch.Draw(drawData.drawTexture, new Vector2((float) (tileX * 16 - (int) screenPosition.X), (float) ((tileY - 1) * 16 - (int) screenPosition.Y)) + screenOffset, new Rectangle?(Minecart.GetSourceRect(38)), drawData.tileLight, 0.0f, new Vector2(), 1f, drawData.tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
|
|
private void DrawTile_LiquidBehindTile(
|
|
bool solidLayer,
|
|
int waterStyleOverride,
|
|
Vector2 screenPosition,
|
|
Vector2 screenOffset,
|
|
int tileX,
|
|
int tileY,
|
|
TileDrawInfo drawData)
|
|
{
|
|
Tile tile1 = Main.tile[tileX + 1, tileY];
|
|
Tile tile2 = Main.tile[tileX - 1, tileY];
|
|
Tile tile3 = Main.tile[tileX, tileY - 1];
|
|
Tile tile4 = Main.tile[tileX, tileY + 1];
|
|
if (tile1 == null)
|
|
{
|
|
tile1 = new Tile();
|
|
Main.tile[tileX + 1, tileY] = tile1;
|
|
}
|
|
if (tile2 == null)
|
|
{
|
|
tile2 = new Tile();
|
|
Main.tile[tileX - 1, tileY] = tile2;
|
|
}
|
|
if (tile3 == null)
|
|
{
|
|
tile3 = new Tile();
|
|
Main.tile[tileX, tileY - 1] = tile3;
|
|
}
|
|
if (tile4 == null)
|
|
{
|
|
tile4 = new Tile();
|
|
Main.tile[tileX, tileY + 1] = tile4;
|
|
}
|
|
if (!solidLayer || drawData.tileCache.inActive() || this._tileSolidTop[(int) drawData.typeCache] || drawData.tileCache.halfBrick() && (tile2.liquid > (byte) 160 || tile1.liquid > (byte) 160) && Main.instance.waterfallManager.CheckForWaterfall(tileX, tileY) || TileID.Sets.BlocksWaterDrawingBehindSelf[(int) drawData.tileCache.type] && drawData.tileCache.slope() == (byte) 0)
|
|
return;
|
|
int num1 = 0;
|
|
bool flag1 = false;
|
|
bool flag2 = false;
|
|
bool flag3 = false;
|
|
bool flag4 = false;
|
|
bool flag5 = false;
|
|
int liquidType = 0;
|
|
bool flag6 = false;
|
|
int num2 = (int) drawData.tileCache.slope();
|
|
int num3 = drawData.tileCache.blockType();
|
|
if (drawData.tileCache.type == (ushort) 546 && drawData.tileCache.liquid > (byte) 0)
|
|
{
|
|
flag5 = true;
|
|
flag4 = true;
|
|
flag1 = true;
|
|
flag2 = true;
|
|
switch (drawData.tileCache.liquidType())
|
|
{
|
|
case 0:
|
|
flag6 = true;
|
|
break;
|
|
case 1:
|
|
liquidType = 1;
|
|
break;
|
|
case 2:
|
|
liquidType = 11;
|
|
break;
|
|
}
|
|
num1 = (int) drawData.tileCache.liquid;
|
|
}
|
|
else
|
|
{
|
|
if (drawData.tileCache.liquid > (byte) 0)
|
|
{
|
|
switch (num3)
|
|
{
|
|
case 0:
|
|
goto label_25;
|
|
case 1:
|
|
if (drawData.tileCache.liquid <= (byte) 160)
|
|
goto label_25;
|
|
else
|
|
break;
|
|
}
|
|
flag5 = true;
|
|
switch (drawData.tileCache.liquidType())
|
|
{
|
|
case 0:
|
|
flag6 = true;
|
|
break;
|
|
case 1:
|
|
liquidType = 1;
|
|
break;
|
|
case 2:
|
|
liquidType = 11;
|
|
break;
|
|
}
|
|
if ((int) drawData.tileCache.liquid > num1)
|
|
num1 = (int) drawData.tileCache.liquid;
|
|
}
|
|
label_25:
|
|
if (tile2.liquid > (byte) 0 && num2 != 1 && num2 != 3)
|
|
{
|
|
flag1 = true;
|
|
switch (tile2.liquidType())
|
|
{
|
|
case 0:
|
|
flag6 = true;
|
|
break;
|
|
case 1:
|
|
liquidType = 1;
|
|
break;
|
|
case 2:
|
|
liquidType = 11;
|
|
break;
|
|
}
|
|
if ((int) tile2.liquid > num1)
|
|
num1 = (int) tile2.liquid;
|
|
}
|
|
if (tile1.liquid > (byte) 0 && num2 != 2 && num2 != 4)
|
|
{
|
|
flag2 = true;
|
|
switch (tile1.liquidType())
|
|
{
|
|
case 0:
|
|
flag6 = true;
|
|
break;
|
|
case 1:
|
|
liquidType = 1;
|
|
break;
|
|
case 2:
|
|
liquidType = 11;
|
|
break;
|
|
}
|
|
if ((int) tile1.liquid > num1)
|
|
num1 = (int) tile1.liquid;
|
|
}
|
|
if (tile3.liquid > (byte) 0 && num2 != 3 && num2 != 4)
|
|
{
|
|
flag3 = true;
|
|
switch (tile3.liquidType())
|
|
{
|
|
case 0:
|
|
flag6 = true;
|
|
break;
|
|
case 1:
|
|
liquidType = 1;
|
|
break;
|
|
case 2:
|
|
liquidType = 11;
|
|
break;
|
|
}
|
|
}
|
|
if (tile4.liquid > (byte) 0 && num2 != 1 && num2 != 2)
|
|
{
|
|
if (tile4.liquid > (byte) 240)
|
|
flag4 = true;
|
|
switch (tile4.liquidType())
|
|
{
|
|
case 0:
|
|
flag6 = true;
|
|
break;
|
|
case 1:
|
|
liquidType = 1;
|
|
break;
|
|
case 2:
|
|
liquidType = 11;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!flag3 && !flag4 && !flag1 && !flag2 && !flag5)
|
|
return;
|
|
if (waterStyleOverride != -1)
|
|
Main.waterStyle = waterStyleOverride;
|
|
if (liquidType == 0)
|
|
liquidType = Main.waterStyle;
|
|
Color color = Lighting.GetColor(tileX, tileY);
|
|
Vector2 vector2 = new Vector2((float) (tileX * 16), (float) (tileY * 16));
|
|
Rectangle liquidSize = new Rectangle(0, 4, 16, 16);
|
|
if (flag4 && flag1 | flag2)
|
|
{
|
|
flag1 = true;
|
|
flag2 = true;
|
|
}
|
|
if ((!flag3 || !(flag1 | flag2)) && !(flag4 & flag3))
|
|
{
|
|
if (flag3)
|
|
{
|
|
liquidSize = new Rectangle(0, 4, 16, 4);
|
|
if (drawData.tileCache.halfBrick() || drawData.tileCache.slope() != (byte) 0)
|
|
liquidSize = new Rectangle(0, 4, 16, 12);
|
|
}
|
|
else if (flag4 && !flag1 && !flag2)
|
|
{
|
|
vector2 = new Vector2((float) (tileX * 16), (float) (tileY * 16 + 12));
|
|
liquidSize = new Rectangle(0, 4, 16, 4);
|
|
}
|
|
else
|
|
{
|
|
float num4 = (float) (256 - num1) / 32f;
|
|
int y = 4;
|
|
if (tile3.liquid == (byte) 0 && (num3 != 0 || !WorldGen.SolidTile(tileX, tileY - 1)))
|
|
y = 0;
|
|
if (drawData.tileCache.slope() != (byte) 0)
|
|
{
|
|
vector2 = new Vector2((float) (tileX * 16), (float) (tileY * 16 + (int) num4 * 2));
|
|
liquidSize = new Rectangle(0, (int) num4 * 2, 16, 16 - (int) num4 * 2);
|
|
}
|
|
else if (flag1 & flag2 || drawData.tileCache.halfBrick())
|
|
{
|
|
vector2 = new Vector2((float) (tileX * 16), (float) (tileY * 16 + (int) num4 * 2));
|
|
liquidSize = new Rectangle(0, y, 16, 16 - (int) num4 * 2);
|
|
}
|
|
else if (flag1)
|
|
{
|
|
vector2 = new Vector2((float) (tileX * 16), (float) (tileY * 16 + (int) num4 * 2));
|
|
liquidSize = new Rectangle(0, y, 4, 16 - (int) num4 * 2);
|
|
}
|
|
else
|
|
{
|
|
vector2 = new Vector2((float) (tileX * 16 + 12), (float) (tileY * 16 + (int) num4 * 2));
|
|
liquidSize = new Rectangle(0, y, 4, 16 - (int) num4 * 2);
|
|
}
|
|
}
|
|
}
|
|
float num5 = 0.5f;
|
|
switch (liquidType)
|
|
{
|
|
case 1:
|
|
num5 = 1f;
|
|
break;
|
|
case 11:
|
|
num5 = Math.Max(num5 * 1.7f, 1f);
|
|
break;
|
|
}
|
|
if ((double) tileY <= Main.worldSurface || (double) num5 > 1.0)
|
|
{
|
|
num5 = 1f;
|
|
if (drawData.tileCache.wall == (ushort) 21)
|
|
num5 = 0.9f;
|
|
else if (drawData.tileCache.wall > (ushort) 0)
|
|
num5 = 0.6f;
|
|
}
|
|
if (drawData.tileCache.halfBrick() && tile3.liquid > (byte) 0 && drawData.tileCache.wall > (ushort) 0)
|
|
num5 = 0.0f;
|
|
if (drawData.tileCache.bottomSlope() && (tile2.liquid == (byte) 0 && !WorldGen.SolidTile(tileX - 1, tileY) || tile1.liquid == (byte) 0 && !WorldGen.SolidTile(tileX + 1, tileY)))
|
|
num5 = 0.0f;
|
|
Color aColor = color * num5;
|
|
bool flag7 = false;
|
|
if (flag6)
|
|
{
|
|
for (int index = 0; index < 13; ++index)
|
|
{
|
|
if (Main.IsLiquidStyleWater(index) && (double) Main.liquidAlpha[index] > 0.0 && index != liquidType)
|
|
{
|
|
this.DrawPartialLiquid(drawData.tileCache, vector2 - screenPosition + screenOffset, liquidSize, index, aColor);
|
|
flag7 = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
this.DrawPartialLiquid(drawData.tileCache, vector2 - screenPosition + screenOffset, liquidSize, liquidType, aColor * (flag7 ? Main.liquidAlpha[liquidType] : 1f));
|
|
}
|
|
|
|
private void CacheSpecialDraws(int tileX, int tileY, TileDrawInfo drawData)
|
|
{
|
|
if (TileID.Sets.BasicChest[(int) drawData.typeCache])
|
|
{
|
|
Point key = new Point(tileX, tileY);
|
|
if ((int) drawData.tileFrameX % 36 != 0)
|
|
--key.X;
|
|
if ((int) drawData.tileFrameY % 36 != 0)
|
|
--key.Y;
|
|
if (!this._chestPositions.ContainsKey(key))
|
|
this._chestPositions[key] = Chest.FindChest(key.X, key.Y);
|
|
int num1 = (int) drawData.tileFrameX / 18;
|
|
int num2 = (int) drawData.tileFrameY / 18;
|
|
int num3 = (int) drawData.tileFrameX / 36;
|
|
int num4 = num1 * 18;
|
|
drawData.addFrX = num4 - (int) drawData.tileFrameX;
|
|
int num5 = num2 * 18;
|
|
if (this._chestPositions[key] != -1)
|
|
{
|
|
int frame = Main.chest[this._chestPositions[key]].frame;
|
|
if (frame == 1)
|
|
num5 += 38;
|
|
if (frame == 2)
|
|
num5 += 76;
|
|
}
|
|
drawData.addFrY = num5 - (int) drawData.tileFrameY;
|
|
if (num2 != 0)
|
|
drawData.tileHeight = 18;
|
|
if (drawData.typeCache == (ushort) 21 && (num3 == 48 || num3 == 49))
|
|
drawData.glowSourceRect = new Rectangle(16 * (num1 % 2), (int) drawData.tileFrameY + drawData.addFrY, drawData.tileWidth, drawData.tileHeight);
|
|
}
|
|
if (drawData.typeCache == (ushort) 378)
|
|
{
|
|
Point key = new Point(tileX, tileY);
|
|
if ((int) drawData.tileFrameX % 36 != 0)
|
|
--key.X;
|
|
if ((int) drawData.tileFrameY % 54 != 0)
|
|
key.Y -= (int) drawData.tileFrameY / 18;
|
|
if (!this._trainingDummyTileEntityPositions.ContainsKey(key))
|
|
this._trainingDummyTileEntityPositions[key] = TETrainingDummy.Find(key.X, key.Y);
|
|
if (this._trainingDummyTileEntityPositions[key] != -1)
|
|
{
|
|
int npc = ((TETrainingDummy) TileEntity.ByID[this._trainingDummyTileEntityPositions[key]]).npc;
|
|
if (npc != -1)
|
|
{
|
|
int num = Main.npc[npc].frame.Y / 55 * 54 + (int) drawData.tileFrameY;
|
|
drawData.addFrY = num - (int) drawData.tileFrameY;
|
|
}
|
|
}
|
|
}
|
|
if (drawData.typeCache == (ushort) 395)
|
|
{
|
|
Point point = new Point(tileX, tileY);
|
|
if ((int) drawData.tileFrameX % 36 != 0)
|
|
--point.X;
|
|
if ((int) drawData.tileFrameY % 36 != 0)
|
|
--point.Y;
|
|
if (!this._itemFrameTileEntityPositions.ContainsKey(point))
|
|
{
|
|
this._itemFrameTileEntityPositions[point] = TEItemFrame.Find(point.X, point.Y);
|
|
if (this._itemFrameTileEntityPositions[point] != -1)
|
|
this.AddSpecialLegacyPoint(point);
|
|
}
|
|
}
|
|
if (drawData.typeCache == (ushort) 520)
|
|
{
|
|
Point point = new Point(tileX, tileY);
|
|
if (!this._foodPlatterTileEntityPositions.ContainsKey(point))
|
|
{
|
|
this._foodPlatterTileEntityPositions[point] = TEFoodPlatter.Find(point.X, point.Y);
|
|
if (this._foodPlatterTileEntityPositions[point] != -1)
|
|
this.AddSpecialLegacyPoint(point);
|
|
}
|
|
}
|
|
if (drawData.typeCache == (ushort) 471)
|
|
{
|
|
Point point = new Point(tileX, tileY);
|
|
point.X -= (int) drawData.tileFrameX % 54 / 18;
|
|
point.Y -= (int) drawData.tileFrameY % 54 / 18;
|
|
if (!this._weaponRackTileEntityPositions.ContainsKey(point))
|
|
{
|
|
this._weaponRackTileEntityPositions[point] = TEWeaponsRack.Find(point.X, point.Y);
|
|
if (this._weaponRackTileEntityPositions[point] != -1)
|
|
this.AddSpecialLegacyPoint(point);
|
|
}
|
|
}
|
|
if (drawData.typeCache == (ushort) 470)
|
|
{
|
|
Point point = new Point(tileX, tileY);
|
|
point.X -= (int) drawData.tileFrameX % 36 / 18;
|
|
point.Y -= (int) drawData.tileFrameY % 54 / 18;
|
|
if (!this._displayDollTileEntityPositions.ContainsKey(point))
|
|
{
|
|
this._displayDollTileEntityPositions[point] = TEDisplayDoll.Find(point.X, point.Y);
|
|
if (this._displayDollTileEntityPositions[point] != -1)
|
|
this.AddSpecialLegacyPoint(point);
|
|
}
|
|
}
|
|
if (drawData.typeCache == (ushort) 475)
|
|
{
|
|
Point point = new Point(tileX, tileY);
|
|
point.X -= (int) drawData.tileFrameX % 54 / 18;
|
|
point.Y -= (int) drawData.tileFrameY % 72 / 18;
|
|
if (!this._hatRackTileEntityPositions.ContainsKey(point))
|
|
{
|
|
this._hatRackTileEntityPositions[point] = TEHatRack.Find(point.X, point.Y);
|
|
if (this._hatRackTileEntityPositions[point] != -1)
|
|
this.AddSpecialLegacyPoint(point);
|
|
}
|
|
}
|
|
if (drawData.typeCache == (ushort) 323 && drawData.tileFrameX <= (short) 132 && drawData.tileFrameX >= (short) 88)
|
|
this.AddSpecialPoint(tileX, tileY, TileDrawing.TileCounterType.Tree);
|
|
if (drawData.typeCache == (ushort) 412 && drawData.tileFrameX == (short) 0 && drawData.tileFrameY == (short) 0)
|
|
this.AddSpecialLegacyPoint(tileX, tileY);
|
|
if (drawData.typeCache == (ushort) 620 && drawData.tileFrameX == (short) 0 && drawData.tileFrameY == (short) 0)
|
|
this.AddSpecialLegacyPoint(tileX, tileY);
|
|
if (drawData.typeCache == (ushort) 237 && drawData.tileFrameX == (short) 18 && drawData.tileFrameY == (short) 0)
|
|
this.AddSpecialLegacyPoint(tileX, tileY);
|
|
switch (drawData.typeCache)
|
|
{
|
|
case 5:
|
|
case 583:
|
|
case 584:
|
|
case 585:
|
|
case 586:
|
|
case 587:
|
|
case 588:
|
|
case 589:
|
|
case 596:
|
|
case 616:
|
|
if (drawData.tileFrameY < (short) 198 || drawData.tileFrameX < (short) 22)
|
|
break;
|
|
this.AddSpecialPoint(tileX, tileY, TileDrawing.TileCounterType.Tree);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private static Color GetFinalLight(
|
|
Tile tileCache,
|
|
ushort typeCache,
|
|
Color tileLight,
|
|
Color tint)
|
|
{
|
|
int num1 = (int) ((double) ((int) tileLight.R * (int) tint.R) / (double) byte.MaxValue);
|
|
int num2 = (int) ((double) ((int) tileLight.G * (int) tint.G) / (double) byte.MaxValue);
|
|
int num3 = (int) ((double) ((int) tileLight.B * (int) tint.B) / (double) byte.MaxValue);
|
|
if (num1 > (int) byte.MaxValue)
|
|
num1 = (int) byte.MaxValue;
|
|
if (num2 > (int) byte.MaxValue)
|
|
num2 = (int) byte.MaxValue;
|
|
if (num3 > (int) byte.MaxValue)
|
|
num3 = (int) byte.MaxValue;
|
|
int num4 = num3 << 16;
|
|
int num5 = num2 << 8;
|
|
tileLight.PackedValue = (uint) (num1 | num5 | num4 | -16777216);
|
|
if (tileCache.color() == (byte) 31)
|
|
tileLight = Color.White;
|
|
if (tileCache.inActive())
|
|
tileLight = tileCache.actColor(tileLight);
|
|
else if (TileDrawing.ShouldTileShine(typeCache, tileCache.frameX))
|
|
tileLight = Main.shine(tileLight, (int) typeCache);
|
|
return tileLight;
|
|
}
|
|
|
|
private static void GetFinalLight(
|
|
Tile tileCache,
|
|
ushort typeCache,
|
|
ref Vector3 tileLight,
|
|
ref Vector3 tint)
|
|
{
|
|
tileLight *= tint;
|
|
if (tileCache.inActive())
|
|
{
|
|
tileCache.actColor(ref tileLight);
|
|
}
|
|
else
|
|
{
|
|
if (!TileDrawing.ShouldTileShine(typeCache, tileCache.frameX))
|
|
return;
|
|
Main.shine(ref tileLight, (int) typeCache);
|
|
}
|
|
}
|
|
|
|
private static bool ShouldTileShine(ushort type, short frameX)
|
|
{
|
|
if (!Main.tileShine2[(int) type])
|
|
return false;
|
|
switch (type)
|
|
{
|
|
case 21:
|
|
case 441:
|
|
return frameX >= (short) 36 && frameX < (short) 178;
|
|
case 467:
|
|
case 468:
|
|
return frameX >= (short) 144 && frameX < (short) 178;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private static bool IsTileDangerous(Player localPlayer, Tile tileCache, ushort typeCache)
|
|
{
|
|
bool flag = typeCache == (ushort) 135 || typeCache == (ushort) 137 || typeCache == (ushort) 138 || typeCache == (ushort) 484 || typeCache == (ushort) 141 || typeCache == (ushort) 210 || typeCache == (ushort) 442 || typeCache == (ushort) 443 || typeCache == (ushort) 444 || typeCache == (ushort) 411 || typeCache == (ushort) 485 || typeCache == (ushort) 85;
|
|
if (tileCache.slope() == (byte) 0 && !tileCache.inActive())
|
|
{
|
|
flag = flag || typeCache == (ushort) 32 || typeCache == (ushort) 69 || typeCache == (ushort) 48 || typeCache == (ushort) 232 || typeCache == (ushort) 352 || typeCache == (ushort) 483 || typeCache == (ushort) 482 || typeCache == (ushort) 481 || typeCache == (ushort) 51 || typeCache == (ushort) 229;
|
|
if (!localPlayer.fireWalk)
|
|
flag = flag || typeCache == (ushort) 37 || typeCache == (ushort) 58 || typeCache == (ushort) 76;
|
|
if (!localPlayer.iceSkate)
|
|
flag = flag || typeCache == (ushort) 162;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
private bool IsTileDrawLayerSolid(ushort typeCache) => TileID.Sets.DrawTileInSolidLayer[(int) typeCache].HasValue ? TileID.Sets.DrawTileInSolidLayer[(int) typeCache].Value : this._tileSolid[(int) typeCache];
|
|
|
|
private void GetTileOutlineInfo(
|
|
int x,
|
|
int y,
|
|
ushort typeCache,
|
|
ref Color tileLight,
|
|
ref Texture2D highlightTexture,
|
|
ref Color highlightColor)
|
|
{
|
|
bool actuallySelected;
|
|
if (!Main.InSmartCursorHighlightArea(x, y, out actuallySelected))
|
|
return;
|
|
int averageTileLighting = ((int) tileLight.R + (int) tileLight.G + (int) tileLight.B) / 3;
|
|
if (averageTileLighting <= 10)
|
|
return;
|
|
highlightTexture = TextureAssets.HighlightMask[(int) typeCache].Value;
|
|
highlightColor = Colors.GetSelectionGlowColor(actuallySelected, averageTileLighting);
|
|
}
|
|
|
|
private void DrawPartialLiquid(
|
|
Tile tileCache,
|
|
Vector2 position,
|
|
Rectangle liquidSize,
|
|
int liquidType,
|
|
Color aColor)
|
|
{
|
|
int num = (int) tileCache.slope();
|
|
if (!TileID.Sets.BlocksWaterDrawingBehindSelf[(int) tileCache.type] || num == 0)
|
|
{
|
|
Main.spriteBatch.Draw(TextureAssets.Liquid[liquidType].Value, position, new Rectangle?(liquidSize), aColor, 0.0f, new Vector2(), 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
else
|
|
{
|
|
liquidSize.X += 18 * (num - 1);
|
|
if (tileCache.slope() == (byte) 1)
|
|
Main.spriteBatch.Draw(TextureAssets.LiquidSlope[liquidType].Value, position, new Rectangle?(liquidSize), aColor, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
else if (tileCache.slope() == (byte) 2)
|
|
Main.spriteBatch.Draw(TextureAssets.LiquidSlope[liquidType].Value, position, new Rectangle?(liquidSize), aColor, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
else if (tileCache.slope() == (byte) 3)
|
|
{
|
|
Main.spriteBatch.Draw(TextureAssets.LiquidSlope[liquidType].Value, position, new Rectangle?(liquidSize), aColor, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
else
|
|
{
|
|
if (tileCache.slope() != (byte) 4)
|
|
return;
|
|
Main.spriteBatch.Draw(TextureAssets.LiquidSlope[liquidType].Value, position, new Rectangle?(liquidSize), aColor, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool InAPlaceWithWind(int x, int y, int width, int height) => WorldGen.InAPlaceWithWind(x, y, width, height);
|
|
|
|
private void GetTileDrawData(
|
|
int x,
|
|
int y,
|
|
Tile tileCache,
|
|
ushort typeCache,
|
|
ref short tileFrameX,
|
|
ref short tileFrameY,
|
|
out int tileWidth,
|
|
out int tileHeight,
|
|
out int tileTop,
|
|
out int halfBrickHeight,
|
|
out int addFrX,
|
|
out int addFrY,
|
|
out SpriteEffects tileSpriteEffect,
|
|
out Texture2D glowTexture,
|
|
out Rectangle glowSourceRect,
|
|
out Color glowColor)
|
|
{
|
|
tileTop = 0;
|
|
tileWidth = 16;
|
|
tileHeight = 16;
|
|
halfBrickHeight = 0;
|
|
addFrY = Main.tileFrame[(int) typeCache] * 38;
|
|
addFrX = 0;
|
|
tileSpriteEffect = SpriteEffects.None;
|
|
glowTexture = (Texture2D) null;
|
|
glowSourceRect = Rectangle.Empty;
|
|
glowColor = Color.Transparent;
|
|
switch (typeCache)
|
|
{
|
|
case 3:
|
|
case 24:
|
|
case 61:
|
|
case 71:
|
|
case 110:
|
|
case 201:
|
|
tileHeight = 20;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 4:
|
|
tileWidth = 20;
|
|
tileHeight = 20;
|
|
if (WorldGen.SolidTile(x, y - 1))
|
|
{
|
|
tileTop = 4;
|
|
break;
|
|
}
|
|
break;
|
|
case 5:
|
|
tileWidth = 20;
|
|
tileHeight = 20;
|
|
int treeBiome = TileDrawing.GetTreeBiome(x, y, (int) tileFrameX, (int) tileFrameY);
|
|
tileFrameX += (short) (176 * (treeBiome + 1));
|
|
break;
|
|
case 12:
|
|
case 31:
|
|
case 96:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 36;
|
|
break;
|
|
case 14:
|
|
case 21:
|
|
case 411:
|
|
case 467:
|
|
case 469:
|
|
if (tileFrameY == (short) 18)
|
|
{
|
|
tileHeight = 18;
|
|
break;
|
|
}
|
|
break;
|
|
case 15:
|
|
case 497:
|
|
if ((int) tileFrameY % 40 == 18)
|
|
{
|
|
tileHeight = 18;
|
|
break;
|
|
}
|
|
break;
|
|
case 16:
|
|
case 17:
|
|
case 18:
|
|
case 26:
|
|
case 32:
|
|
case 69:
|
|
case 72:
|
|
case 77:
|
|
case 79:
|
|
case 124:
|
|
case 137:
|
|
case 138:
|
|
case 352:
|
|
case 462:
|
|
case 487:
|
|
case 488:
|
|
case 574:
|
|
case 575:
|
|
case 576:
|
|
case 577:
|
|
case 578:
|
|
tileHeight = 18;
|
|
break;
|
|
case 20:
|
|
case 590:
|
|
case 595:
|
|
tileHeight = 18;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 27:
|
|
if ((int) tileFrameY % 74 == 54)
|
|
{
|
|
tileHeight = 18;
|
|
break;
|
|
}
|
|
break;
|
|
case 28:
|
|
case 105:
|
|
case 470:
|
|
case 475:
|
|
case 506:
|
|
case 547:
|
|
case 548:
|
|
case 552:
|
|
case 560:
|
|
case 597:
|
|
case 613:
|
|
case 621:
|
|
case 622:
|
|
tileTop = 2;
|
|
break;
|
|
case 33:
|
|
case 49:
|
|
case 174:
|
|
case 372:
|
|
tileHeight = 20;
|
|
tileTop = -4;
|
|
break;
|
|
case 52:
|
|
case 62:
|
|
case 115:
|
|
case 205:
|
|
case 382:
|
|
case 528:
|
|
tileTop = -2;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 73:
|
|
case 74:
|
|
case 113:
|
|
tileTop = -12;
|
|
tileHeight = 32;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 78:
|
|
case 85:
|
|
case 100:
|
|
case 133:
|
|
case 134:
|
|
case 173:
|
|
case 210:
|
|
case 233:
|
|
case 254:
|
|
case 283:
|
|
case 378:
|
|
case 457:
|
|
case 466:
|
|
case 520:
|
|
tileTop = 2;
|
|
break;
|
|
case 80:
|
|
case 142:
|
|
case 143:
|
|
tileTop = 2;
|
|
break;
|
|
case 81:
|
|
tileTop -= 8;
|
|
tileHeight = 26;
|
|
tileWidth = 24;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 82:
|
|
case 83:
|
|
case 84:
|
|
tileHeight = 20;
|
|
tileTop = -2;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 89:
|
|
tileTop = 2;
|
|
break;
|
|
case 102:
|
|
tileTop = 2;
|
|
break;
|
|
case 106:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 54;
|
|
break;
|
|
case 129:
|
|
addFrY = 0;
|
|
if (tileFrameX >= (short) 324)
|
|
{
|
|
int num1 = ((int) tileFrameX - 324) / 18;
|
|
int num2 = (num1 + Main.tileFrame[(int) typeCache]) % 6 - num1;
|
|
addFrX = num2 * 18;
|
|
break;
|
|
}
|
|
break;
|
|
case 132:
|
|
case 135:
|
|
tileTop = 2;
|
|
tileHeight = 18;
|
|
break;
|
|
case 136:
|
|
if (tileFrameX == (short) 0)
|
|
{
|
|
tileTop = 2;
|
|
break;
|
|
}
|
|
break;
|
|
case 139:
|
|
tileTop = 2;
|
|
int num3 = (int) tileFrameY / 2016;
|
|
addFrY -= 2016 * num3;
|
|
addFrX += 72 * num3;
|
|
break;
|
|
case 172:
|
|
case 376:
|
|
if ((int) tileFrameY % 38 == 18)
|
|
{
|
|
tileHeight = 18;
|
|
break;
|
|
}
|
|
break;
|
|
case 178:
|
|
if (tileFrameY <= (short) 36)
|
|
{
|
|
tileTop = 2;
|
|
break;
|
|
}
|
|
break;
|
|
case 184:
|
|
tileWidth = 20;
|
|
if (tileFrameY <= (short) 36)
|
|
{
|
|
tileTop = 2;
|
|
break;
|
|
}
|
|
if (tileFrameY <= (short) 108)
|
|
{
|
|
tileTop = -2;
|
|
break;
|
|
}
|
|
break;
|
|
case 185:
|
|
case 186:
|
|
case 187:
|
|
tileTop = 2;
|
|
switch (typeCache)
|
|
{
|
|
case 185:
|
|
Main.tileShine2[185] = tileFrameY == (short) 18 && tileFrameX >= (short) 576 && tileFrameX <= (short) 882;
|
|
if (tileFrameY == (short) 18)
|
|
{
|
|
int num4 = (int) tileFrameX / 1908;
|
|
addFrX -= 1908 * num4;
|
|
addFrY += 18 * num4;
|
|
break;
|
|
}
|
|
break;
|
|
case 186:
|
|
Main.tileShine2[186] = tileFrameX >= (short) 864 && tileFrameX <= (short) 1170;
|
|
break;
|
|
case 187:
|
|
int num5 = (int) tileFrameX / 1890;
|
|
addFrX -= 1890 * num5;
|
|
addFrY += 36 * num5;
|
|
break;
|
|
}
|
|
break;
|
|
case 207:
|
|
tileTop = 2;
|
|
if (tileFrameY >= (short) 72)
|
|
{
|
|
addFrY = Main.tileFrame[(int) typeCache];
|
|
int num6 = x;
|
|
if ((int) tileFrameX % 36 != 0)
|
|
--num6;
|
|
addFrY += num6 % 6;
|
|
if (addFrY >= 6)
|
|
addFrY -= 6;
|
|
addFrY *= 72;
|
|
break;
|
|
}
|
|
addFrY = 0;
|
|
break;
|
|
case 215:
|
|
addFrY = tileFrameY >= (short) 36 ? 252 : Main.tileFrame[(int) typeCache] * 36;
|
|
tileTop = 2;
|
|
break;
|
|
case 217:
|
|
case 218:
|
|
case 564:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 36;
|
|
tileTop = 2;
|
|
break;
|
|
case 219:
|
|
case 220:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 54;
|
|
tileTop = 2;
|
|
break;
|
|
case 227:
|
|
tileWidth = 32;
|
|
tileHeight = 38;
|
|
if (tileFrameX == (short) 238)
|
|
tileTop -= 6;
|
|
else
|
|
tileTop -= 20;
|
|
if (tileFrameX == (short) 204)
|
|
{
|
|
bool evil;
|
|
bool good;
|
|
bool crimson;
|
|
this.GetCactusType(x, y, (int) tileFrameX, (int) tileFrameY, out evil, out good, out crimson);
|
|
if (good)
|
|
tileFrameX += (short) 238;
|
|
if (evil)
|
|
tileFrameX += (short) 204;
|
|
if (crimson)
|
|
tileFrameX += (short) 272;
|
|
}
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 228:
|
|
case 231:
|
|
case 243:
|
|
case 247:
|
|
tileTop = 2;
|
|
addFrY = Main.tileFrame[(int) typeCache] * 54;
|
|
break;
|
|
case 235:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 18;
|
|
break;
|
|
case 238:
|
|
tileTop = 2;
|
|
addFrY = Main.tileFrame[(int) typeCache] * 36;
|
|
break;
|
|
case 244:
|
|
tileTop = 2;
|
|
addFrY = tileFrameX >= (short) 54 ? 0 : Main.tileFrame[(int) typeCache] * 36;
|
|
break;
|
|
case 270:
|
|
case 271:
|
|
case 581:
|
|
int num7 = Main.tileFrame[(int) typeCache] + x % 6;
|
|
if (x % 2 == 0)
|
|
num7 += 3;
|
|
if (x % 3 == 0)
|
|
num7 += 3;
|
|
if (x % 4 == 0)
|
|
num7 += 3;
|
|
while (num7 > 5)
|
|
num7 -= 6;
|
|
addFrX = num7 * 18;
|
|
addFrY = 0;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 272:
|
|
addFrY = 0;
|
|
break;
|
|
case 275:
|
|
case 276:
|
|
case 277:
|
|
case 278:
|
|
case 279:
|
|
case 280:
|
|
case 281:
|
|
case 296:
|
|
case 297:
|
|
case 309:
|
|
case 358:
|
|
case 359:
|
|
case 413:
|
|
case 414:
|
|
case 542:
|
|
case 550:
|
|
case 551:
|
|
case 553:
|
|
case 554:
|
|
case 558:
|
|
case 559:
|
|
case 599:
|
|
case 600:
|
|
case 601:
|
|
case 602:
|
|
case 603:
|
|
case 604:
|
|
case 605:
|
|
case 606:
|
|
case 607:
|
|
case 608:
|
|
case 609:
|
|
case 610:
|
|
case 611:
|
|
case 612:
|
|
tileTop = 2;
|
|
Main.critterCage = true;
|
|
int bigAnimalCageFrame = this.GetBigAnimalCageFrame(x, y, (int) tileFrameX, (int) tileFrameY);
|
|
switch (typeCache)
|
|
{
|
|
case 275:
|
|
case 359:
|
|
case 599:
|
|
case 600:
|
|
case 601:
|
|
case 602:
|
|
case 603:
|
|
case 604:
|
|
case 605:
|
|
addFrY = Main.bunnyCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 276:
|
|
case 413:
|
|
case 414:
|
|
case 606:
|
|
case 607:
|
|
case 608:
|
|
case 609:
|
|
case 610:
|
|
case 611:
|
|
case 612:
|
|
addFrY = Main.squirrelCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 277:
|
|
addFrY = Main.mallardCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 278:
|
|
addFrY = Main.duckCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 279:
|
|
case 358:
|
|
addFrY = Main.birdCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 280:
|
|
addFrY = Main.blueBirdCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 281:
|
|
addFrY = Main.redBirdCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 296:
|
|
case 297:
|
|
addFrY = Main.scorpionCageFrame[0, bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 309:
|
|
addFrY = Main.penguinCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 542:
|
|
addFrY = Main.owlCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 550:
|
|
case 551:
|
|
addFrY = Main.turtleCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 553:
|
|
addFrY = Main.grebeCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 554:
|
|
addFrY = Main.seagullCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
case 558:
|
|
case 559:
|
|
addFrY = Main.seahorseCageFrame[bigAnimalCageFrame] * 54;
|
|
break;
|
|
}
|
|
break;
|
|
case 282:
|
|
case 505:
|
|
case 543:
|
|
tileTop = 2;
|
|
Main.critterCage = true;
|
|
int waterAnimalCageFrame1 = this.GetWaterAnimalCageFrame(x, y, (int) tileFrameX, (int) tileFrameY);
|
|
addFrY = Main.fishBowlFrame[waterAnimalCageFrame1] * 36;
|
|
break;
|
|
case 285:
|
|
case 286:
|
|
case 298:
|
|
case 299:
|
|
case 310:
|
|
case 339:
|
|
case 361:
|
|
case 362:
|
|
case 363:
|
|
case 364:
|
|
case 391:
|
|
case 392:
|
|
case 393:
|
|
case 394:
|
|
case 532:
|
|
case 533:
|
|
case 538:
|
|
case 544:
|
|
case 555:
|
|
case 556:
|
|
case 582:
|
|
case 619:
|
|
tileTop = 2;
|
|
Main.critterCage = true;
|
|
int smallAnimalCageFrame1 = this.GetSmallAnimalCageFrame(x, y, (int) tileFrameX, (int) tileFrameY);
|
|
switch (typeCache)
|
|
{
|
|
case 285:
|
|
addFrY = Main.snailCageFrame[smallAnimalCageFrame1] * 36;
|
|
break;
|
|
case 286:
|
|
case 582:
|
|
addFrY = Main.snail2CageFrame[smallAnimalCageFrame1] * 36;
|
|
break;
|
|
case 298:
|
|
case 361:
|
|
addFrY = Main.frogCageFrame[smallAnimalCageFrame1] * 36;
|
|
break;
|
|
case 299:
|
|
case 363:
|
|
addFrY = Main.mouseCageFrame[smallAnimalCageFrame1] * 36;
|
|
break;
|
|
case 310:
|
|
case 364:
|
|
case 391:
|
|
case 619:
|
|
addFrY = Main.wormCageFrame[smallAnimalCageFrame1] * 36;
|
|
break;
|
|
case 339:
|
|
case 362:
|
|
addFrY = Main.grasshopperCageFrame[smallAnimalCageFrame1] * 36;
|
|
break;
|
|
case 392:
|
|
case 393:
|
|
case 394:
|
|
addFrY = Main.slugCageFrame[(int) typeCache - 392, smallAnimalCageFrame1] * 36;
|
|
break;
|
|
case 532:
|
|
addFrY = Main.maggotCageFrame[smallAnimalCageFrame1] * 36;
|
|
break;
|
|
case 533:
|
|
addFrY = Main.ratCageFrame[smallAnimalCageFrame1] * 36;
|
|
break;
|
|
case 538:
|
|
case 544:
|
|
addFrY = Main.ladybugCageFrame[smallAnimalCageFrame1] * 36;
|
|
break;
|
|
case 555:
|
|
case 556:
|
|
addFrY = Main.waterStriderCageFrame[smallAnimalCageFrame1] * 36;
|
|
break;
|
|
}
|
|
break;
|
|
case 288:
|
|
case 289:
|
|
case 290:
|
|
case 291:
|
|
case 292:
|
|
case 293:
|
|
case 294:
|
|
case 295:
|
|
case 360:
|
|
case 580:
|
|
case 620:
|
|
tileTop = 2;
|
|
Main.critterCage = true;
|
|
int waterAnimalCageFrame2 = this.GetWaterAnimalCageFrame(x, y, (int) tileFrameX, (int) tileFrameY);
|
|
int index1 = (int) typeCache - 288;
|
|
if (typeCache == (ushort) 360 || typeCache == (ushort) 580 || typeCache == (ushort) 620)
|
|
index1 = 8;
|
|
addFrY = Main.butterflyCageFrame[index1, waterAnimalCageFrame2] * 36;
|
|
break;
|
|
case 300:
|
|
case 301:
|
|
case 302:
|
|
case 303:
|
|
case 304:
|
|
case 305:
|
|
case 306:
|
|
case 307:
|
|
case 308:
|
|
case 354:
|
|
case 355:
|
|
case 499:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 54;
|
|
tileTop = 2;
|
|
break;
|
|
case 316:
|
|
case 317:
|
|
case 318:
|
|
tileTop = 2;
|
|
Main.critterCage = true;
|
|
int smallAnimalCageFrame2 = this.GetSmallAnimalCageFrame(x, y, (int) tileFrameX, (int) tileFrameY);
|
|
int index2 = (int) typeCache - 316;
|
|
addFrY = Main.jellyfishCageFrame[index2, smallAnimalCageFrame2] * 36;
|
|
break;
|
|
case 323:
|
|
tileWidth = 20;
|
|
tileHeight = 20;
|
|
int palmTreeBiome = this.GetPalmTreeBiome(x, y);
|
|
tileFrameY = (short) (22 * palmTreeBiome);
|
|
break;
|
|
case 324:
|
|
tileWidth = 20;
|
|
tileHeight = 20;
|
|
tileTop = -2;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 326:
|
|
case 327:
|
|
case 328:
|
|
case 329:
|
|
case 345:
|
|
case 351:
|
|
case 421:
|
|
case 422:
|
|
case 458:
|
|
case 459:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 90;
|
|
break;
|
|
case 330:
|
|
case 331:
|
|
case 332:
|
|
case 333:
|
|
tileTop += 2;
|
|
break;
|
|
case 336:
|
|
case 340:
|
|
case 341:
|
|
case 342:
|
|
case 343:
|
|
case 344:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 90;
|
|
tileTop = 2;
|
|
break;
|
|
case 349:
|
|
tileTop = 2;
|
|
int num8 = (int) tileFrameX % 36;
|
|
int num9 = (int) tileFrameY % 54;
|
|
int frameData1;
|
|
if (Animation.GetTemporaryFrame(x - num8 / 18, y - num9 / 18, out frameData1))
|
|
{
|
|
tileFrameX = (short) (36 * frameData1 + num8);
|
|
break;
|
|
}
|
|
break;
|
|
case 377:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 38;
|
|
tileTop = 2;
|
|
break;
|
|
case 379:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 90;
|
|
break;
|
|
case 388:
|
|
case 389:
|
|
TileObjectData.GetTileData((int) typeCache, (int) tileFrameX / 18);
|
|
int num10 = 94;
|
|
tileTop = -2;
|
|
if ((int) tileFrameY == num10 - 20 || (int) tileFrameY == num10 * 2 - 20 || tileFrameY == (short) 0 || (int) tileFrameY == num10)
|
|
tileHeight = 18;
|
|
if (tileFrameY != (short) 0 && (int) tileFrameY != num10)
|
|
{
|
|
tileTop = 0;
|
|
break;
|
|
}
|
|
break;
|
|
case 390:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 36;
|
|
break;
|
|
case 405:
|
|
tileHeight = 16;
|
|
if (tileFrameY > (short) 0)
|
|
tileHeight = 18;
|
|
int num11 = Main.tileFrame[(int) typeCache];
|
|
if (tileFrameX >= (short) 54)
|
|
num11 = 0;
|
|
addFrY = num11 * 38;
|
|
break;
|
|
case 406:
|
|
tileHeight = 16;
|
|
if ((int) tileFrameY % 54 >= 36)
|
|
tileHeight = 18;
|
|
int num12 = Main.tileFrame[(int) typeCache];
|
|
if (tileFrameY >= (short) 108)
|
|
num12 = 6 - (int) tileFrameY / 54;
|
|
else if (tileFrameY >= (short) 54)
|
|
num12 = Main.tileFrame[(int) typeCache] - 1;
|
|
addFrY = num12 * 56;
|
|
addFrY += (int) tileFrameY / 54 * 2;
|
|
break;
|
|
case 410:
|
|
if (tileFrameY == (short) 36)
|
|
tileHeight = 18;
|
|
if (tileFrameY >= (short) 56)
|
|
{
|
|
addFrY = Main.tileFrame[(int) typeCache];
|
|
addFrY *= 56;
|
|
break;
|
|
}
|
|
addFrY = 0;
|
|
break;
|
|
case 412:
|
|
addFrY = 0;
|
|
tileTop = 2;
|
|
break;
|
|
case 426:
|
|
case 430:
|
|
case 431:
|
|
case 432:
|
|
case 433:
|
|
case 434:
|
|
addFrY = 90;
|
|
break;
|
|
case 428:
|
|
tileTop += 4;
|
|
if (PressurePlateHelper.PressurePlatesPressed.ContainsKey(new Point(x, y)))
|
|
{
|
|
addFrX += 18;
|
|
break;
|
|
}
|
|
break;
|
|
case 441:
|
|
case 468:
|
|
if (tileFrameY == (short) 18)
|
|
tileHeight = 18;
|
|
int num13 = (int) tileFrameX % 36;
|
|
int num14 = (int) tileFrameY % 38;
|
|
int frameData2;
|
|
if (Animation.GetTemporaryFrame(x - num13 / 18, y - num14 / 18, out frameData2))
|
|
{
|
|
tileFrameY = (short) (38 * frameData2 + num14);
|
|
break;
|
|
}
|
|
break;
|
|
case 442:
|
|
tileWidth = 20;
|
|
tileHeight = 20;
|
|
switch ((int) tileFrameX / 22)
|
|
{
|
|
case 1:
|
|
tileTop = -4;
|
|
break;
|
|
case 2:
|
|
tileTop = -2;
|
|
tileWidth = 24;
|
|
break;
|
|
case 3:
|
|
tileTop = -2;
|
|
break;
|
|
}
|
|
break;
|
|
case 452:
|
|
int num15 = Main.tileFrame[(int) typeCache];
|
|
if (tileFrameX >= (short) 54)
|
|
num15 = 0;
|
|
addFrY = num15 * 54;
|
|
break;
|
|
case 453:
|
|
int num16 = (Main.tileFrameCounter[(int) typeCache] / 20 + (y - (int) tileFrameY / 18 + x)) % 3;
|
|
addFrY = num16 * 54;
|
|
break;
|
|
case 454:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 54;
|
|
break;
|
|
case 455:
|
|
addFrY = 0;
|
|
tileTop = 2;
|
|
int num17 = 1 + Main.tileFrame[(int) typeCache];
|
|
if (!BirthdayParty.PartyIsUp)
|
|
num17 = 0;
|
|
addFrY = num17 * 54;
|
|
break;
|
|
case 456:
|
|
int num18 = (Main.tileFrameCounter[(int) typeCache] / 20 + (y - (int) tileFrameY / 18 + (x - (int) tileFrameX / 18))) % 4;
|
|
addFrY = num18 * 54;
|
|
break;
|
|
case 463:
|
|
case 464:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 72;
|
|
tileTop = 2;
|
|
break;
|
|
case 476:
|
|
tileWidth = 20;
|
|
tileHeight = 18;
|
|
break;
|
|
case 480:
|
|
case 509:
|
|
if (tileFrameY >= (short) 54)
|
|
{
|
|
addFrY = Main.tileFrame[(int) typeCache];
|
|
addFrY *= 54;
|
|
break;
|
|
}
|
|
addFrY = 0;
|
|
break;
|
|
case 485:
|
|
tileTop = 2;
|
|
int num19 = (Main.tileFrameCounter[(int) typeCache] / 5 + (y - (int) tileFrameY / 18 + (x - (int) tileFrameX / 18))) % 4;
|
|
addFrY = num19 * 36;
|
|
break;
|
|
case 489:
|
|
tileTop = 2;
|
|
int y1 = y - (int) tileFrameY / 18;
|
|
int x1 = x - (int) tileFrameX / 18;
|
|
if (this.InAPlaceWithWind(x1, y1, 2, 3))
|
|
{
|
|
int num20 = (Main.tileFrameCounter[(int) typeCache] / 5 + (y1 + x1)) % 16;
|
|
addFrY = num20 * 54;
|
|
break;
|
|
}
|
|
break;
|
|
case 490:
|
|
tileTop = 2;
|
|
int y2 = y - (int) tileFrameY / 18;
|
|
int num21 = this.InAPlaceWithWind(x - (int) tileFrameX / 18, y2, 2, 2) ? 1 : 0;
|
|
int num22 = num21 != 0 ? Main.tileFrame[(int) typeCache] : 0;
|
|
int num23 = 0;
|
|
if (num21 != 0)
|
|
{
|
|
if ((double) Math.Abs(Main.WindForVisuals) > 0.5)
|
|
{
|
|
switch (Main.weatherVaneBobframe)
|
|
{
|
|
case 0:
|
|
num23 = 0;
|
|
break;
|
|
case 1:
|
|
num23 = 1;
|
|
break;
|
|
case 2:
|
|
num23 = 2;
|
|
break;
|
|
case 3:
|
|
num23 = 1;
|
|
break;
|
|
case 4:
|
|
num23 = 0;
|
|
break;
|
|
case 5:
|
|
num23 = -1;
|
|
break;
|
|
case 6:
|
|
num23 = -2;
|
|
break;
|
|
case 7:
|
|
num23 = -1;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (Main.weatherVaneBobframe)
|
|
{
|
|
case 0:
|
|
num23 = 0;
|
|
break;
|
|
case 1:
|
|
num23 = 1;
|
|
break;
|
|
case 2:
|
|
num23 = 0;
|
|
break;
|
|
case 3:
|
|
num23 = -1;
|
|
break;
|
|
case 4:
|
|
num23 = 0;
|
|
break;
|
|
case 5:
|
|
num23 = 1;
|
|
break;
|
|
case 6:
|
|
num23 = 0;
|
|
break;
|
|
case 7:
|
|
num23 = -1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
int num24 = num22 + num23;
|
|
if (num24 < 0)
|
|
num24 += 12;
|
|
int num25 = num24 % 12;
|
|
addFrY = num25 * 36;
|
|
break;
|
|
case 491:
|
|
tileTop = 2;
|
|
addFrX = 54;
|
|
break;
|
|
case 493:
|
|
if (tileFrameY == (short) 0)
|
|
{
|
|
int num26 = Main.tileFrameCounter[(int) typeCache];
|
|
float num27 = Math.Abs(Main.WindForVisuals);
|
|
int y3 = y - (int) tileFrameY / 18;
|
|
int x2 = x - (int) tileFrameX / 18;
|
|
if (!this.InAPlaceWithWind(x2, y3, 1, 1))
|
|
num27 = 0.0f;
|
|
if ((double) num27 >= 0.100000001490116)
|
|
{
|
|
if ((double) num27 < 0.5)
|
|
{
|
|
int num28 = (num26 / 20 + (y3 + x2)) % 6;
|
|
int num29 = (double) Main.WindForVisuals >= 0.0 ? num28 + 1 : 6 - num28;
|
|
addFrY = num29 * 36;
|
|
}
|
|
else
|
|
{
|
|
int num30 = (num26 / 10 + (y3 + x2)) % 6;
|
|
int num31 = (double) Main.WindForVisuals >= 0.0 ? num30 + 7 : 12 - num30;
|
|
addFrY = num31 * 36;
|
|
}
|
|
}
|
|
}
|
|
tileTop = 2;
|
|
break;
|
|
case 494:
|
|
tileTop = 2;
|
|
break;
|
|
case 507:
|
|
case 508:
|
|
int num32 = 20;
|
|
int num33 = (Main.tileFrameCounter[(int) typeCache] + x * 11 + y * 27) % (num32 * 8);
|
|
addFrY = 90 * (num33 / num32);
|
|
break;
|
|
case 518:
|
|
int num34 = (int) tileCache.liquid / 16 - 3;
|
|
if (WorldGen.SolidTile(x, y - 1) && num34 > 8)
|
|
num34 = 8;
|
|
if (tileCache.liquid == (byte) 0)
|
|
{
|
|
Tile tileSafely = Framing.GetTileSafely(x, y + 1);
|
|
if (tileSafely.nactive())
|
|
{
|
|
switch (tileSafely.blockType())
|
|
{
|
|
case 1:
|
|
num34 = Math.Max(8, (int) tileSafely.liquid / 16) - 16;
|
|
break;
|
|
case 2:
|
|
case 3:
|
|
num34 -= 4;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
tileTop -= num34;
|
|
break;
|
|
case 519:
|
|
tileTop = 2;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 521:
|
|
case 522:
|
|
case 523:
|
|
case 524:
|
|
case 525:
|
|
case 526:
|
|
case 527:
|
|
tileTop = 2;
|
|
Main.critterCage = true;
|
|
int waterAnimalCageFrame3 = this.GetWaterAnimalCageFrame(x, y, (int) tileFrameX, (int) tileFrameY);
|
|
int index3 = (int) typeCache - 521;
|
|
addFrY = Main.dragonflyJarFrame[index3, waterAnimalCageFrame3] * 36;
|
|
break;
|
|
case 529:
|
|
int num35 = y + 1;
|
|
int num36 = x;
|
|
int corruptCount1;
|
|
int crimsonCount1;
|
|
int hallowedCount1;
|
|
WorldGen.GetBiomeInfluence(num36, num36, num35, num35, out corruptCount1, out crimsonCount1, out hallowedCount1);
|
|
int num37 = corruptCount1;
|
|
if (num37 < crimsonCount1)
|
|
num37 = crimsonCount1;
|
|
if (num37 < hallowedCount1)
|
|
num37 = hallowedCount1;
|
|
int num38 = corruptCount1 != 0 || crimsonCount1 != 0 || hallowedCount1 != 0 ? (hallowedCount1 != num37 ? (crimsonCount1 != num37 ? 4 : 3) : 2) : (x < WorldGen.beachDistance || x > Main.maxTilesX - WorldGen.beachDistance ? 1 : 0);
|
|
addFrY += 34 * num38 - (int) tileFrameY;
|
|
tileHeight = 32;
|
|
tileTop = -14;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 530:
|
|
int num39 = y - (int) tileFrameY % 36 / 18 + 2;
|
|
int startX = x - (int) tileFrameX % 54 / 18;
|
|
int corruptCount2;
|
|
int crimsonCount2;
|
|
int hallowedCount2;
|
|
WorldGen.GetBiomeInfluence(startX, startX + 3, num39, num39, out corruptCount2, out crimsonCount2, out hallowedCount2);
|
|
int num40 = corruptCount2;
|
|
if (num40 < crimsonCount2)
|
|
num40 = crimsonCount2;
|
|
if (num40 < hallowedCount2)
|
|
num40 = hallowedCount2;
|
|
int num41 = corruptCount2 != 0 || crimsonCount2 != 0 || hallowedCount2 != 0 ? (hallowedCount2 != num40 ? (crimsonCount2 != num40 ? 3 : 2) : 1) : 0;
|
|
addFrY += 36 * num41;
|
|
tileTop = 2;
|
|
break;
|
|
case 541:
|
|
addFrY = this._shouldShowInvisibleBlocks ? 0 : 90;
|
|
break;
|
|
case 561:
|
|
tileTop -= 2;
|
|
tileHeight = 20;
|
|
addFrY = (int) tileFrameY / 18 * 4;
|
|
break;
|
|
case 565:
|
|
tileTop = 2;
|
|
addFrY = tileFrameX >= (short) 36 ? 0 : Main.tileFrame[(int) typeCache] * 36;
|
|
break;
|
|
case 567:
|
|
tileWidth = 26;
|
|
tileHeight = 18;
|
|
tileTop = 2;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 568:
|
|
case 569:
|
|
case 570:
|
|
tileTop = 2;
|
|
Main.critterCage = true;
|
|
int waterAnimalCageFrame4 = this.GetWaterAnimalCageFrame(x, y, (int) tileFrameX, (int) tileFrameY);
|
|
addFrY = Main.fairyJarFrame[waterAnimalCageFrame4] * 36;
|
|
break;
|
|
case 571:
|
|
if (x % 2 == 0)
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
tileTop = 2;
|
|
break;
|
|
case 572:
|
|
int num42 = Main.tileFrame[(int) typeCache] + x % 6;
|
|
while (num42 > 3)
|
|
num42 -= 3;
|
|
addFrX = num42 * 18;
|
|
addFrY = 0;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 579:
|
|
tileWidth = 20;
|
|
tileHeight = 20;
|
|
tileTop -= 2;
|
|
bool flag = (double) (x * 16 + 8) > (double) Main.LocalPlayer.Center.X;
|
|
addFrY = tileFrameX <= (short) 0 ? (!flag ? 22 : 0) : (!flag ? 0 : 22);
|
|
break;
|
|
case 583:
|
|
case 584:
|
|
case 585:
|
|
case 586:
|
|
case 587:
|
|
case 588:
|
|
case 589:
|
|
case 596:
|
|
case 616:
|
|
tileWidth = 20;
|
|
tileHeight = 20;
|
|
break;
|
|
case 592:
|
|
addFrY = Main.tileFrame[(int) typeCache] * 54;
|
|
break;
|
|
case 593:
|
|
if (tileFrameX >= (short) 18)
|
|
addFrX = -18;
|
|
tileTop = 2;
|
|
int frameData3;
|
|
addFrY = !Animation.GetTemporaryFrame(x, y, out frameData3) ? (tileFrameX >= (short) 18 ? 0 : Main.tileFrame[(int) typeCache] * 18) : (int) (short) (18 * frameData3);
|
|
break;
|
|
case 594:
|
|
if (tileFrameX >= (short) 36)
|
|
addFrX = -36;
|
|
tileTop = 2;
|
|
int num43 = (int) tileFrameX % 36;
|
|
int num44 = (int) tileFrameY % 36;
|
|
int frameData4;
|
|
addFrY = !Animation.GetTemporaryFrame(x - num43 / 18, y - num44 / 18, out frameData4) ? (tileFrameX >= (short) 36 ? 0 : Main.tileFrame[(int) typeCache] * 36) : (int) (short) (36 * frameData4);
|
|
break;
|
|
case 598:
|
|
tileTop = 2;
|
|
Main.critterCage = true;
|
|
int waterAnimalCageFrame5 = this.GetWaterAnimalCageFrame(x, y, (int) tileFrameX, (int) tileFrameY);
|
|
addFrY = Main.lavaFishBowlFrame[waterAnimalCageFrame5] * 36;
|
|
break;
|
|
case 614:
|
|
addFrX = Main.tileFrame[(int) typeCache] * 54;
|
|
addFrY = 0;
|
|
tileTop = 2;
|
|
break;
|
|
case 615:
|
|
tileHeight = 18;
|
|
if (x % 2 == 0)
|
|
{
|
|
tileSpriteEffect = SpriteEffects.FlipHorizontally;
|
|
break;
|
|
}
|
|
break;
|
|
case 617:
|
|
tileTop = 2;
|
|
tileFrameY %= (short) 144;
|
|
tileFrameX %= (short) 54;
|
|
break;
|
|
}
|
|
if (tileCache.halfBrick())
|
|
halfBrickHeight = 8;
|
|
switch (typeCache)
|
|
{
|
|
case 10:
|
|
if ((int) tileFrameY / 54 != 32)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[57].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 54, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
break;
|
|
case 11:
|
|
int num45 = (int) tileFrameY / 54;
|
|
if (num45 == 32)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[58].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 54, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num45 != 33)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[119].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 54, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 14:
|
|
int num46 = (int) tileFrameX / 54;
|
|
if (num46 == 31)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[67].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 54, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num46 != 32)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[124].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 54, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 15:
|
|
int num47 = (int) tileFrameY / 40;
|
|
if (num47 == 32)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[54].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 40, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num47 != 33)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[116].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 40, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 18:
|
|
int num48 = (int) tileFrameX / 36;
|
|
if (num48 == 27)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[69].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 36, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num48 != 28)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[125].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 36, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 19:
|
|
int num49 = (int) tileFrameY / 18;
|
|
if (num49 == 26)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[65].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 18, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num49 != 27)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[112].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 18, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 21:
|
|
case 467:
|
|
int num50 = (int) tileFrameX / 36;
|
|
if (num50 == 48)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[56].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 36, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num50 != 49)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[117].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 36, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 33:
|
|
if ((int) tileFrameX / 18 != 0 || (int) tileFrameY / 22 != 26)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[61].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 22, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
break;
|
|
case 34:
|
|
if ((int) tileFrameX / 54 != 0 || (int) tileFrameY / 54 != 33)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[55].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 54, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
break;
|
|
case 42:
|
|
if ((int) tileFrameY / 36 != 33)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[63].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 36, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
break;
|
|
case 79:
|
|
int num51 = (int) tileFrameY / 36;
|
|
if (num51 == 27)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[53].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 36, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num51 != 28)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[114].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 36, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 87:
|
|
int num52 = (int) tileFrameX / 54;
|
|
int num53 = (int) tileFrameX / 1998;
|
|
addFrX -= 1998 * num53;
|
|
addFrY += 36 * num53;
|
|
if (num52 == 26)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[64].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 54, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num52 != 27)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[121].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 54, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 88:
|
|
int num54 = (int) tileFrameX / 54;
|
|
int num55 = (int) tileFrameX / 1998;
|
|
addFrX -= 1998 * num55;
|
|
addFrY += 36 * num55;
|
|
if (num54 == 24)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[59].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 54, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num54 != 25)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[120].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 54, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 89:
|
|
int num56 = (int) tileFrameX / 54;
|
|
int num57 = (int) tileFrameX / 1998;
|
|
addFrX -= 1998 * num57;
|
|
addFrY += 36 * num57;
|
|
if (num56 == 29)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[66].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 54, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num56 != 30)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[123].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 54, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 90:
|
|
int num58 = (int) tileFrameY / 36;
|
|
if (num58 == 27)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[52].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 36, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num58 != 28)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[113].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 36, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 93:
|
|
int num59 = (int) tileFrameY / 54;
|
|
int num60 = (int) tileFrameY / 1998;
|
|
addFrY -= 1998 * num60;
|
|
addFrX += 36 * num60;
|
|
tileTop += 2;
|
|
if (num59 != 27)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[62].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 54, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
break;
|
|
case 100:
|
|
if ((int) tileFrameX / 36 != 0 || (int) tileFrameY / 36 != 27)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[68].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 36, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
break;
|
|
case 101:
|
|
int num61 = (int) tileFrameX / 54;
|
|
int num62 = (int) tileFrameX / 1998;
|
|
addFrX -= 1998 * num62;
|
|
addFrY += 72 * num62;
|
|
if (num61 == 28)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[60].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 54, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num61 != 29)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[115].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 54, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 104:
|
|
int num63 = (int) tileFrameX / 36;
|
|
tileTop = 2;
|
|
if (num63 == 24)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[51].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 36, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num63 != 25)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[118].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 36, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 172:
|
|
int num64 = (int) tileFrameY / 38;
|
|
if (num64 == 28)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[88].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 38, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num64 != 29)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[122].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY % 38, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 184:
|
|
if (tileCache.frameX == (short) 110)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[(int) sbyte.MaxValue].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._lavaMossGlow;
|
|
}
|
|
if (tileCache.frameX == (short) 132)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[(int) sbyte.MaxValue].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._kryptonMossGlow;
|
|
}
|
|
if (tileCache.frameX == (short) 154)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[(int) sbyte.MaxValue].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._xenonMossGlow;
|
|
}
|
|
if (tileCache.frameX != (short) 176)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[(int) sbyte.MaxValue].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._argonMossGlow;
|
|
break;
|
|
case 441:
|
|
case 468:
|
|
int num65 = (int) tileFrameX / 36;
|
|
if (num65 == 48)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[56].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 36, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._martianGlow;
|
|
}
|
|
if (num65 != 49)
|
|
break;
|
|
glowTexture = TextureAssets.GlowMask[117].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX % 36, (int) tileFrameY, tileWidth, tileHeight);
|
|
glowColor = this._meteorGlow;
|
|
break;
|
|
case 463:
|
|
glowTexture = TextureAssets.GlowMask[243].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY + addFrY, tileWidth, tileHeight);
|
|
glowColor = new Color((int) sbyte.MaxValue, (int) sbyte.MaxValue, (int) sbyte.MaxValue, 0);
|
|
break;
|
|
case 564:
|
|
if (tileCache.frameX < (short) 36)
|
|
{
|
|
glowTexture = TextureAssets.GlowMask[267].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY + addFrY, tileWidth, tileHeight);
|
|
glowColor = new Color(200, 200, 200, 0) * ((float) Main.mouseTextColor / (float) byte.MaxValue);
|
|
}
|
|
addFrY = 0;
|
|
break;
|
|
case 568:
|
|
glowTexture = TextureAssets.GlowMask[268].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY + addFrY, tileWidth, tileHeight);
|
|
glowColor = Color.White;
|
|
break;
|
|
case 569:
|
|
glowTexture = TextureAssets.GlowMask[269].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY + addFrY, tileWidth, tileHeight);
|
|
glowColor = Color.White;
|
|
break;
|
|
case 570:
|
|
glowTexture = TextureAssets.GlowMask[270].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY + addFrY, tileWidth, tileHeight);
|
|
glowColor = Color.White;
|
|
break;
|
|
case 580:
|
|
glowTexture = TextureAssets.GlowMask[289].Value;
|
|
glowSourceRect = new Rectangle((int) tileFrameX, (int) tileFrameY + addFrY, tileWidth, tileHeight);
|
|
glowColor = new Color(225, 110, 110, 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private bool IsWindBlocked(int x, int y)
|
|
{
|
|
Tile tile = Main.tile[x, y];
|
|
return tile == null || tile.wall > (ushort) 0 && !WallID.Sets.AllowsWind[(int) tile.wall] || (double) y > Main.worldSurface;
|
|
}
|
|
|
|
private int GetWaterAnimalCageFrame(int x, int y, int tileFrameX, int tileFrameY) => (x - tileFrameX / 18) / 2 * ((y - tileFrameY / 18) / 3) % Main.cageFrames;
|
|
|
|
private int GetSmallAnimalCageFrame(int x, int y, int tileFrameX, int tileFrameY) => (x - tileFrameX / 18) / 3 * ((y - tileFrameY / 18) / 3) % Main.cageFrames;
|
|
|
|
private int GetBigAnimalCageFrame(int x, int y, int tileFrameX, int tileFrameY) => (x - tileFrameX / 18) / 6 * ((y - tileFrameY / 18) / 4) % Main.cageFrames;
|
|
|
|
private void GetScreenDrawArea(
|
|
Vector2 screenPosition,
|
|
Vector2 offSet,
|
|
out int firstTileX,
|
|
out int lastTileX,
|
|
out int firstTileY,
|
|
out int lastTileY)
|
|
{
|
|
firstTileX = (int) (((double) screenPosition.X - (double) offSet.X) / 16.0 - 1.0);
|
|
lastTileX = (int) (((double) screenPosition.X + (double) Main.screenWidth + (double) offSet.X) / 16.0) + 2;
|
|
firstTileY = (int) (((double) screenPosition.Y - (double) offSet.Y) / 16.0 - 1.0);
|
|
lastTileY = (int) (((double) screenPosition.Y + (double) Main.screenHeight + (double) offSet.Y) / 16.0) + 5;
|
|
if (firstTileX < 4)
|
|
firstTileX = 4;
|
|
if (lastTileX > Main.maxTilesX - 4)
|
|
lastTileX = Main.maxTilesX - 4;
|
|
if (firstTileY < 4)
|
|
firstTileY = 4;
|
|
if (lastTileY > Main.maxTilesY - 4)
|
|
lastTileY = Main.maxTilesY - 4;
|
|
if (Main.sectionManager.FrameSectionsLeft <= 0)
|
|
return;
|
|
TimeLogger.DetailedDrawReset();
|
|
WorldGen.SectionTileFrameWithCheck(firstTileX, firstTileY, lastTileX, lastTileY);
|
|
TimeLogger.DetailedDrawTime(5);
|
|
}
|
|
|
|
public void ClearCachedTileDraws(bool solidLayer)
|
|
{
|
|
if (!solidLayer)
|
|
return;
|
|
this._displayDollTileEntityPositions.Clear();
|
|
this._hatRackTileEntityPositions.Clear();
|
|
this._vineRootsPositions.Clear();
|
|
this._reverseVineRootsPositions.Clear();
|
|
}
|
|
|
|
private void AddSpecialLegacyPoint(Point p) => this.AddSpecialLegacyPoint(p.X, p.Y);
|
|
|
|
private void AddSpecialLegacyPoint(int x, int y)
|
|
{
|
|
this._specialTileX[this._specialTilesCount] = x;
|
|
this._specialTileY[this._specialTilesCount] = y;
|
|
++this._specialTilesCount;
|
|
}
|
|
|
|
private void ClearLegacyCachedDraws()
|
|
{
|
|
this._chestPositions.Clear();
|
|
this._trainingDummyTileEntityPositions.Clear();
|
|
this._foodPlatterTileEntityPositions.Clear();
|
|
this._itemFrameTileEntityPositions.Clear();
|
|
this._weaponRackTileEntityPositions.Clear();
|
|
this._specialTilesCount = 0;
|
|
}
|
|
|
|
private Color DrawTiles_GetLightOverride(
|
|
int j,
|
|
int i,
|
|
Tile tileCache,
|
|
ushort typeCache,
|
|
short tileFrameX,
|
|
short tileFrameY,
|
|
Color tileLight)
|
|
{
|
|
if (tileCache.color() == (byte) 31)
|
|
return Color.White;
|
|
switch (typeCache)
|
|
{
|
|
case 61:
|
|
if (tileFrameX == (short) 144)
|
|
{
|
|
tileLight.A = tileLight.R = tileLight.G = tileLight.B = (byte) (245.0 - (double) Main.mouseTextColor * 1.5);
|
|
break;
|
|
}
|
|
break;
|
|
case 83:
|
|
int style = (int) tileFrameX / 18;
|
|
if (this.IsAlchemyPlantHarvestable(style))
|
|
{
|
|
if (style == 5)
|
|
{
|
|
tileLight.A = (byte) ((uint) Main.mouseTextColor / 2U);
|
|
tileLight.G = Main.mouseTextColor;
|
|
tileLight.B = Main.mouseTextColor;
|
|
}
|
|
if (style == 6)
|
|
{
|
|
byte num1 = (byte) (((int) Main.mouseTextColor + (int) tileLight.G * 2) / 3);
|
|
byte num2 = (byte) (((int) Main.mouseTextColor + (int) tileLight.B * 2) / 3);
|
|
if ((int) num1 > (int) tileLight.G)
|
|
tileLight.G = num1;
|
|
if ((int) num2 > (int) tileLight.B)
|
|
{
|
|
tileLight.B = num2;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case 541:
|
|
return Color.White;
|
|
}
|
|
return tileLight;
|
|
}
|
|
|
|
private void DrawTiles_EmitParticles(
|
|
int j,
|
|
int i,
|
|
Tile tileCache,
|
|
ushort typeCache,
|
|
short tileFrameX,
|
|
short tileFrameY,
|
|
Color tileLight)
|
|
{
|
|
switch (typeCache)
|
|
{
|
|
case 238:
|
|
if (this._rand.Next(10) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 168);
|
|
this._dust[index].noGravity = true;
|
|
this._dust[index].alpha = 200;
|
|
break;
|
|
}
|
|
break;
|
|
case 463:
|
|
if (tileFrameY == (short) 54 && tileFrameX == (short) 0)
|
|
{
|
|
for (int index = 0; index < 4; ++index)
|
|
{
|
|
if (this._rand.Next(2) != 0)
|
|
{
|
|
Dust dust = Dust.NewDustDirect(new Vector2((float) (i * 16 + 4), (float) (j * 16)), 36, 8, 16);
|
|
dust.noGravity = true;
|
|
dust.alpha = 140;
|
|
dust.fadeIn = 1.2f;
|
|
dust.velocity = Vector2.Zero;
|
|
}
|
|
}
|
|
}
|
|
if (tileFrameY == (short) 18 && (tileFrameX == (short) 0 || tileFrameX == (short) 36))
|
|
{
|
|
for (int index = 0; index < 1; ++index)
|
|
{
|
|
if (this._rand.Next(13) == 0)
|
|
{
|
|
Dust dust = Dust.NewDustDirect(new Vector2((float) (i * 16), (float) (j * 16)), 8, 8, 274);
|
|
dust.position = new Vector2((float) (i * 16 + 8), (float) (j * 16 + 8));
|
|
dust.position.X += tileFrameX == (short) 36 ? 4f : -4f;
|
|
dust.noGravity = true;
|
|
dust.alpha = 128;
|
|
dust.fadeIn = 1.2f;
|
|
dust.noLight = true;
|
|
dust.velocity = new Vector2(0.0f, this._rand.NextFloatDirection() * 1.2f);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
if (typeCache == (ushort) 497 && (int) tileCache.frameY / 40 == 31 && (int) tileCache.frameY % 40 == 0)
|
|
{
|
|
for (int index = 0; index < 1; ++index)
|
|
{
|
|
if (this._rand.Next(10) == 0)
|
|
{
|
|
Dust dust = Dust.NewDustDirect(new Vector2((float) (i * 16), (float) (j * 16 + 8)), 16, 12, 43);
|
|
dust.noGravity = true;
|
|
dust.alpha = 254;
|
|
dust.color = Color.White;
|
|
dust.scale = 0.7f;
|
|
dust.velocity = Vector2.Zero;
|
|
dust.noLight = true;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (typeCache == (ushort) 139 && tileCache.frameX == (short) 36 && (int) tileCache.frameY % 36 == 0 && (int) Main.timeForVisualEffects % 7 == 0 && this._rand.Next(3) == 0)
|
|
{
|
|
int Type = this._rand.Next(570, 573);
|
|
Vector2 Position = new Vector2((float) (i * 16 + 8), (float) (j * 16 - 8));
|
|
Vector2 Velocity = new Vector2(Main.WindForVisuals * 2f, -0.5f);
|
|
Velocity.X *= (float) (1.0 + (double) this._rand.Next(-50, 51) * 0.00999999977648258);
|
|
Velocity.Y *= (float) (1.0 + (double) this._rand.Next(-50, 51) * 0.00999999977648258);
|
|
if (Type == 572)
|
|
Position.X -= 8f;
|
|
if (Type == 571)
|
|
Position.X -= 4f;
|
|
Gore.NewGore(Position, Velocity, Type, 0.8f);
|
|
}
|
|
if (typeCache == (ushort) 244 && tileFrameX == (short) 18 && tileFrameY == (short) 18 && this._rand.Next(2) == 0)
|
|
{
|
|
if (this._rand.Next(500) == 0)
|
|
Gore.NewGore(new Vector2((float) (i * 16 + 8), (float) (j * 16 + 8)), new Vector2(), 415, (float) this._rand.Next(51, 101) * 0.01f);
|
|
else if (this._rand.Next(250) == 0)
|
|
Gore.NewGore(new Vector2((float) (i * 16 + 8), (float) (j * 16 + 8)), new Vector2(), 414, (float) this._rand.Next(51, 101) * 0.01f);
|
|
else if (this._rand.Next(80) == 0)
|
|
Gore.NewGore(new Vector2((float) (i * 16 + 8), (float) (j * 16 + 8)), new Vector2(), 413, (float) this._rand.Next(51, 101) * 0.01f);
|
|
else if (this._rand.Next(10) == 0)
|
|
Gore.NewGore(new Vector2((float) (i * 16 + 8), (float) (j * 16 + 8)), new Vector2(), 412, (float) this._rand.Next(51, 101) * 0.01f);
|
|
else if (this._rand.Next(3) == 0)
|
|
Gore.NewGore(new Vector2((float) (i * 16 + 8), (float) (j * 16 + 8)), new Vector2(), 411, (float) this._rand.Next(51, 101) * 0.01f);
|
|
}
|
|
if (typeCache == (ushort) 565 && tileFrameX == (short) 0 && tileFrameY == (short) 18 && this._rand.Next(3) == 0 && (Main.drawToScreen && this._rand.Next(4) == 0 || !Main.drawToScreen))
|
|
{
|
|
Vector2 worldCoordinates = new Point(i, j).ToWorldCoordinates();
|
|
int Type = 1202;
|
|
float Scale = (float) (8.0 + (double) Main.rand.NextFloat() * 1.60000002384186);
|
|
Vector2 vector2 = new Vector2(0.0f, -18f);
|
|
Gore.NewGorePerfect(worldCoordinates + vector2, (Main.rand.NextVector2Circular(0.7f, 0.25f) * 0.4f + Main.rand.NextVector2CircularEdge(1f, 0.4f) * 0.1f) * 4f, Type, Scale);
|
|
}
|
|
if (typeCache == (ushort) 165 && tileFrameX >= (short) 162 && tileFrameX <= (short) 214 && tileFrameY == (short) 72 && this._rand.Next(60) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16 + 2), (float) (j * 16 + 6)), 8, 4, 153);
|
|
this._dust[index].scale -= (float) this._rand.Next(3) * 0.1f;
|
|
this._dust[index].velocity.Y = 0.0f;
|
|
this._dust[index].velocity.X *= 0.05f;
|
|
this._dust[index].alpha = 100;
|
|
}
|
|
if (typeCache == (ushort) 42 && tileFrameX == (short) 0)
|
|
{
|
|
int num1 = (int) tileFrameY / 36;
|
|
int num2 = (int) tileFrameY / 18 % 2;
|
|
if (num1 == 7 && num2 == 1)
|
|
{
|
|
if (this._rand.Next(50) == 0)
|
|
this._dust[Dust.NewDust(new Vector2((float) (i * 16 + 4), (float) (j * 16 + 4)), 8, 8, 58, Alpha: 150)].velocity *= 0.5f;
|
|
if (this._rand.Next(100) == 0)
|
|
{
|
|
int index = Gore.NewGore(new Vector2((float) (i * 16 - 2), (float) (j * 16 - 4)), new Vector2(), this._rand.Next(16, 18));
|
|
this._gore[index].scale *= 0.7f;
|
|
this._gore[index].velocity *= 0.25f;
|
|
}
|
|
}
|
|
else if (num1 == 29 && num2 == 1 && this._rand.Next(40) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16 + 4), (float) (j * 16)), 8, 8, 59, Alpha: 100);
|
|
if (this._rand.Next(3) != 0)
|
|
this._dust[index].noGravity = true;
|
|
this._dust[index].velocity *= 0.3f;
|
|
this._dust[index].velocity.Y -= 1.5f;
|
|
}
|
|
}
|
|
if (typeCache == (ushort) 215 && tileFrameY < (short) 36 && this._rand.Next(3) == 0 && (Main.drawToScreen && this._rand.Next(4) == 0 || !Main.drawToScreen) && tileFrameY == (short) 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16 + 2), (float) (j * 16 - 4)), 4, 8, 31, Alpha: 100);
|
|
if (tileFrameX == (short) 0)
|
|
this._dust[index].position.X += (float) this._rand.Next(8);
|
|
if (tileFrameX == (short) 36)
|
|
this._dust[index].position.X -= (float) this._rand.Next(8);
|
|
this._dust[index].alpha += this._rand.Next(100);
|
|
this._dust[index].velocity *= 0.2f;
|
|
this._dust[index].velocity.Y -= (float) (0.5 + (double) this._rand.Next(10) * 0.100000001490116);
|
|
this._dust[index].fadeIn = (float) (0.5 + (double) this._rand.Next(10) * 0.100000001490116);
|
|
}
|
|
if (typeCache == (ushort) 592 && tileFrameY == (short) 18 && this._rand.Next(3) == 0 && (Main.drawToScreen && this._rand.Next(6) == 0 || !Main.drawToScreen))
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16 + 2), (float) (j * 16 + 4)), 4, 8, 31, Alpha: 100);
|
|
if (tileFrameX == (short) 0)
|
|
this._dust[index].position.X += (float) this._rand.Next(8);
|
|
if (tileFrameX == (short) 36)
|
|
this._dust[index].position.X -= (float) this._rand.Next(8);
|
|
this._dust[index].alpha += this._rand.Next(100);
|
|
this._dust[index].velocity *= 0.2f;
|
|
this._dust[index].velocity.Y -= (float) (0.5 + (double) this._rand.Next(10) * 0.100000001490116);
|
|
this._dust[index].fadeIn = (float) (0.5 + (double) this._rand.Next(10) * 0.100000001490116);
|
|
}
|
|
if (typeCache == (ushort) 4 && this._rand.Next(40) == 0 && tileFrameX < (short) 66)
|
|
{
|
|
int num = (int) tileFrameY / 22;
|
|
int Type;
|
|
switch (num)
|
|
{
|
|
case 0:
|
|
Type = 6;
|
|
break;
|
|
case 8:
|
|
Type = 75;
|
|
break;
|
|
case 9:
|
|
Type = 135;
|
|
break;
|
|
case 10:
|
|
Type = 158;
|
|
break;
|
|
case 11:
|
|
Type = 169;
|
|
break;
|
|
case 12:
|
|
Type = 156;
|
|
break;
|
|
case 13:
|
|
Type = 234;
|
|
break;
|
|
case 14:
|
|
Type = 66;
|
|
break;
|
|
case 15:
|
|
Type = 242;
|
|
break;
|
|
case 16:
|
|
Type = 293;
|
|
break;
|
|
case 17:
|
|
Type = 294;
|
|
break;
|
|
default:
|
|
Type = 58 + num;
|
|
break;
|
|
}
|
|
int index;
|
|
switch (tileFrameX)
|
|
{
|
|
case 22:
|
|
index = Dust.NewDust(new Vector2((float) (i * 16 + 6), (float) (j * 16)), 4, 4, Type, Alpha: 100);
|
|
break;
|
|
case 44:
|
|
index = Dust.NewDust(new Vector2((float) (i * 16 + 2), (float) (j * 16)), 4, 4, Type, Alpha: 100);
|
|
break;
|
|
default:
|
|
index = Dust.NewDust(new Vector2((float) (i * 16 + 4), (float) (j * 16)), 4, 4, Type, Alpha: 100);
|
|
break;
|
|
}
|
|
if (this._rand.Next(3) != 0)
|
|
this._dust[index].noGravity = true;
|
|
this._dust[index].velocity *= 0.3f;
|
|
this._dust[index].velocity.Y -= 1.5f;
|
|
if (Type == 66)
|
|
{
|
|
this._dust[index].color = new Color(Main.DiscoR, Main.DiscoG, Main.DiscoB);
|
|
this._dust[index].noGravity = true;
|
|
}
|
|
}
|
|
if (typeCache == (ushort) 93 && this._rand.Next(40) == 0 && tileFrameX == (short) 0)
|
|
{
|
|
int num = (int) tileFrameY / 54;
|
|
if ((int) tileFrameY / 18 % 3 == 0)
|
|
{
|
|
int Type;
|
|
switch (num)
|
|
{
|
|
case 0:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 10:
|
|
case 14:
|
|
case 15:
|
|
case 16:
|
|
Type = 6;
|
|
break;
|
|
case 20:
|
|
Type = 59;
|
|
break;
|
|
default:
|
|
Type = -1;
|
|
break;
|
|
}
|
|
if (Type != -1)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16 + 4), (float) (j * 16 + 2)), 4, 4, Type, Alpha: 100);
|
|
if (this._rand.Next(3) != 0)
|
|
this._dust[index].noGravity = true;
|
|
this._dust[index].velocity *= 0.3f;
|
|
this._dust[index].velocity.Y -= 1.5f;
|
|
}
|
|
}
|
|
}
|
|
if (typeCache == (ushort) 100 && this._rand.Next(40) == 0 && tileFrameX < (short) 36)
|
|
{
|
|
int num = (int) tileFrameY / 36;
|
|
if ((int) tileFrameY / 18 % 2 == 0)
|
|
{
|
|
int Type;
|
|
switch (num)
|
|
{
|
|
case 0:
|
|
case 5:
|
|
case 7:
|
|
case 8:
|
|
case 10:
|
|
case 12:
|
|
case 14:
|
|
case 15:
|
|
case 16:
|
|
Type = 6;
|
|
break;
|
|
case 20:
|
|
Type = 59;
|
|
break;
|
|
default:
|
|
Type = -1;
|
|
break;
|
|
}
|
|
if (Type != -1)
|
|
{
|
|
int index = Dust.NewDust(tileFrameX != (short) 0 ? (this._rand.Next(3) != 0 ? new Vector2((float) (i * 16), (float) (j * 16 + 2)) : new Vector2((float) (i * 16 + 6), (float) (j * 16 + 2))) : (this._rand.Next(3) != 0 ? new Vector2((float) (i * 16 + 14), (float) (j * 16 + 2)) : new Vector2((float) (i * 16 + 4), (float) (j * 16 + 2))), 4, 4, Type, Alpha: 100);
|
|
if (this._rand.Next(3) != 0)
|
|
this._dust[index].noGravity = true;
|
|
this._dust[index].velocity *= 0.3f;
|
|
this._dust[index].velocity.Y -= 1.5f;
|
|
}
|
|
}
|
|
}
|
|
if (typeCache == (ushort) 98 && this._rand.Next(40) == 0 && tileFrameY == (short) 0 && tileFrameX == (short) 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16 + 12), (float) (j * 16 + 2)), 4, 4, 6, Alpha: 100);
|
|
if (this._rand.Next(3) != 0)
|
|
this._dust[index].noGravity = true;
|
|
this._dust[index].velocity *= 0.3f;
|
|
this._dust[index].velocity.Y -= 1.5f;
|
|
}
|
|
if (typeCache == (ushort) 49 && tileFrameX == (short) 0 && this._rand.Next(2) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16 + 4), (float) (j * 16 - 4)), 4, 4, 172, Alpha: 100);
|
|
if (this._rand.Next(3) == 0)
|
|
{
|
|
this._dust[index].scale = 0.5f;
|
|
}
|
|
else
|
|
{
|
|
this._dust[index].scale = 0.9f;
|
|
this._dust[index].noGravity = true;
|
|
}
|
|
this._dust[index].velocity *= 0.3f;
|
|
this._dust[index].velocity.Y -= 1.5f;
|
|
}
|
|
if (typeCache == (ushort) 372 && tileFrameX == (short) 0 && this._rand.Next(2) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16 + 4), (float) (j * 16 - 4)), 4, 4, 242, Alpha: 100);
|
|
if (this._rand.Next(3) == 0)
|
|
{
|
|
this._dust[index].scale = 0.5f;
|
|
}
|
|
else
|
|
{
|
|
this._dust[index].scale = 0.9f;
|
|
this._dust[index].noGravity = true;
|
|
}
|
|
this._dust[index].velocity *= 0.3f;
|
|
this._dust[index].velocity.Y -= 1.5f;
|
|
}
|
|
if (typeCache == (ushort) 34 && this._rand.Next(40) == 0 && tileFrameX < (short) 54)
|
|
{
|
|
int num3 = (int) tileFrameY / 54;
|
|
int num4 = (int) tileFrameX / 18 % 3;
|
|
if ((int) tileFrameY / 18 % 3 == 1 && num4 != 1)
|
|
{
|
|
int Type;
|
|
switch (num3)
|
|
{
|
|
case 0:
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 12:
|
|
case 13:
|
|
case 16:
|
|
case 19:
|
|
case 21:
|
|
Type = 6;
|
|
break;
|
|
case 25:
|
|
Type = 59;
|
|
break;
|
|
default:
|
|
Type = -1;
|
|
break;
|
|
}
|
|
if (Type != -1)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16 + 2)), 14, 6, Type, Alpha: 100);
|
|
if (this._rand.Next(3) != 0)
|
|
this._dust[index].noGravity = true;
|
|
this._dust[index].velocity *= 0.3f;
|
|
this._dust[index].velocity.Y -= 1.5f;
|
|
}
|
|
}
|
|
}
|
|
int maxValue = this._leafFrequency / 4;
|
|
if (typeCache == (ushort) 192 && this._rand.Next(maxValue) == 0)
|
|
this.EmitLivingTreeLeaf(i, j, 910);
|
|
if (typeCache == (ushort) 384 && this._rand.Next(maxValue) == 0)
|
|
this.EmitLivingTreeLeaf(i, j, 914);
|
|
if (typeCache == (ushort) 83)
|
|
{
|
|
int style = (int) tileFrameX / 18;
|
|
if (this.IsAlchemyPlantHarvestable(style))
|
|
this.EmitAlchemyHerbParticles(j, i, style);
|
|
}
|
|
if (typeCache == (ushort) 22 && this._rand.Next(400) == 0)
|
|
Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 14);
|
|
else if ((typeCache == (ushort) 23 || typeCache == (ushort) 24 || typeCache == (ushort) 32) && this._rand.Next(500) == 0)
|
|
Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 14);
|
|
else if (typeCache == (ushort) 25 && this._rand.Next(700) == 0)
|
|
Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 14);
|
|
else if (typeCache == (ushort) 112 && this._rand.Next(700) == 0)
|
|
Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 14);
|
|
else if (typeCache == (ushort) 31 && this._rand.Next(20) == 0)
|
|
{
|
|
if (tileFrameX >= (short) 36)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 5, Alpha: 100);
|
|
this._dust[index].velocity.Y = 0.0f;
|
|
this._dust[index].velocity.X *= 0.3f;
|
|
}
|
|
else
|
|
Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 14, Alpha: 100);
|
|
}
|
|
else if (typeCache == (ushort) 26 && this._rand.Next(20) == 0)
|
|
{
|
|
if (tileFrameX >= (short) 54)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 5, Alpha: 100);
|
|
this._dust[index].scale = 1.5f;
|
|
this._dust[index].noGravity = true;
|
|
this._dust[index].velocity *= 0.75f;
|
|
}
|
|
else
|
|
Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 14, Alpha: 100);
|
|
}
|
|
else if ((typeCache == (ushort) 71 || typeCache == (ushort) 72) && this._rand.Next(500) == 0)
|
|
Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 41, Alpha: 250, Scale: 0.8f);
|
|
else if ((typeCache == (ushort) 17 || typeCache == (ushort) 77 || typeCache == (ushort) 133) && this._rand.Next(40) == 0)
|
|
{
|
|
if (!(tileFrameX == (short) 18 & tileFrameY == (short) 18))
|
|
return;
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16 - 4), (float) (j * 16 - 6)), 8, 6, 6, Alpha: 100);
|
|
if (this._rand.Next(3) == 0)
|
|
return;
|
|
this._dust[index].noGravity = true;
|
|
}
|
|
else if (typeCache == (ushort) 405 && this._rand.Next(20) == 0)
|
|
{
|
|
if (!(tileFrameX == (short) 18 & tileFrameY == (short) 18))
|
|
return;
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16 - 4), (float) (j * 16 - 6)), 24, 10, 6, Alpha: 100);
|
|
if (this._rand.Next(5) == 0)
|
|
return;
|
|
this._dust[index].noGravity = true;
|
|
}
|
|
else if (typeCache == (ushort) 452 && tileFrameY == (short) 0 && tileFrameX == (short) 0 && this._rand.Next(3) == 0)
|
|
{
|
|
Vector2 Position = new Vector2((float) (i * 16 + 16), (float) (j * 16 + 8));
|
|
Vector2 Velocity = new Vector2(0.0f, 0.0f);
|
|
if ((double) Main.WindForVisuals < 0.0)
|
|
Velocity.X = -Main.WindForVisuals;
|
|
int Type = 907 + Main.tileFrame[(int) typeCache] / 5;
|
|
if (this._rand.Next(2) != 0)
|
|
return;
|
|
Gore.NewGore(Position, Velocity, Type, (float) ((double) this._rand.NextFloat() * 0.400000005960464 + 0.400000005960464));
|
|
}
|
|
else if (typeCache == (ushort) 406 && tileFrameY == (short) 54 && tileFrameX == (short) 0 && this._rand.Next(3) == 0)
|
|
{
|
|
Vector2 Position = new Vector2((float) (i * 16 + 16), (float) (j * 16 + 8));
|
|
Vector2 Velocity = new Vector2(0.0f, 0.0f);
|
|
if ((double) Main.WindForVisuals < 0.0)
|
|
Velocity.X = -Main.WindForVisuals;
|
|
int Type = this._rand.Next(825, 828);
|
|
if (this._rand.Next(4) == 0)
|
|
Gore.NewGore(Position, Velocity, Type, (float) ((double) this._rand.NextFloat() * 0.200000002980232 + 0.200000002980232));
|
|
else if (this._rand.Next(2) == 0)
|
|
Gore.NewGore(Position, Velocity, Type, (float) ((double) this._rand.NextFloat() * 0.300000011920929 + 0.300000011920929));
|
|
else
|
|
Gore.NewGore(Position, Velocity, Type, (float) ((double) this._rand.NextFloat() * 0.400000005960464 + 0.400000005960464));
|
|
}
|
|
else if (typeCache == (ushort) 37 && this._rand.Next(250) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 6, Scale: ((float) this._rand.Next(3)));
|
|
if ((double) this._dust[index].scale <= 1.0)
|
|
return;
|
|
this._dust[index].noGravity = true;
|
|
}
|
|
else if ((typeCache == (ushort) 58 || typeCache == (ushort) 76) && this._rand.Next(250) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 6, Scale: ((float) this._rand.Next(3)));
|
|
if ((double) this._dust[index].scale > 1.0)
|
|
this._dust[index].noGravity = true;
|
|
this._dust[index].noLight = true;
|
|
}
|
|
else if (typeCache == (ushort) 61)
|
|
{
|
|
if (tileFrameX != (short) 144 || this._rand.Next(60) != 0)
|
|
return;
|
|
this._dust[Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 44, Alpha: 250, Scale: 0.4f)].fadeIn = 0.7f;
|
|
}
|
|
else
|
|
{
|
|
if (Main.tileShine[(int) typeCache] <= 0 || tileLight.R <= (byte) 20 && tileLight.B <= (byte) 20 && tileLight.G <= (byte) 20)
|
|
return;
|
|
int num5 = (int) tileLight.R;
|
|
if ((int) tileLight.G > num5)
|
|
num5 = (int) tileLight.G;
|
|
if ((int) tileLight.B > num5)
|
|
num5 = (int) tileLight.B;
|
|
int num6 = num5 / 30;
|
|
if (this._rand.Next(Main.tileShine[(int) typeCache]) >= num6 || (typeCache == (ushort) 21 || typeCache == (ushort) 441) && (tileFrameX < (short) 36 || tileFrameX >= (short) 180) && (tileFrameX < (short) 396 || tileFrameX > (short) 409) || (typeCache == (ushort) 467 || typeCache == (ushort) 468) && (tileFrameX < (short) 144 || tileFrameX >= (short) 180))
|
|
return;
|
|
Color newColor = Color.White;
|
|
if (typeCache == (ushort) 178)
|
|
{
|
|
switch ((int) tileFrameX / 18)
|
|
{
|
|
case 0:
|
|
newColor = new Color((int) byte.MaxValue, 0, (int) byte.MaxValue, (int) byte.MaxValue);
|
|
break;
|
|
case 1:
|
|
newColor = new Color((int) byte.MaxValue, (int) byte.MaxValue, 0, (int) byte.MaxValue);
|
|
break;
|
|
case 2:
|
|
newColor = new Color(0, 0, (int) byte.MaxValue, (int) byte.MaxValue);
|
|
break;
|
|
case 3:
|
|
newColor = new Color(0, (int) byte.MaxValue, 0, (int) byte.MaxValue);
|
|
break;
|
|
case 4:
|
|
newColor = new Color((int) byte.MaxValue, 0, 0, (int) byte.MaxValue);
|
|
break;
|
|
case 5:
|
|
newColor = new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue);
|
|
break;
|
|
case 6:
|
|
newColor = new Color((int) byte.MaxValue, (int) byte.MaxValue, 0, (int) byte.MaxValue);
|
|
break;
|
|
}
|
|
this._dust[Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 43, Alpha: 254, newColor: newColor, Scale: 0.5f)].velocity *= 0.0f;
|
|
}
|
|
else
|
|
{
|
|
if (typeCache == (ushort) 63)
|
|
newColor = new Color(0, 0, (int) byte.MaxValue, (int) byte.MaxValue);
|
|
if (typeCache == (ushort) 64)
|
|
newColor = new Color((int) byte.MaxValue, 0, 0, (int) byte.MaxValue);
|
|
if (typeCache == (ushort) 65)
|
|
newColor = new Color(0, (int) byte.MaxValue, 0, (int) byte.MaxValue);
|
|
if (typeCache == (ushort) 66)
|
|
newColor = new Color((int) byte.MaxValue, (int) byte.MaxValue, 0, (int) byte.MaxValue);
|
|
if (typeCache == (ushort) 67)
|
|
newColor = new Color((int) byte.MaxValue, 0, (int) byte.MaxValue, (int) byte.MaxValue);
|
|
if (typeCache == (ushort) 68)
|
|
newColor = new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue);
|
|
if (typeCache == (ushort) 12)
|
|
newColor = new Color((int) byte.MaxValue, 0, 0, (int) byte.MaxValue);
|
|
if (typeCache == (ushort) 204)
|
|
newColor = new Color((int) byte.MaxValue, 0, 0, (int) byte.MaxValue);
|
|
if (typeCache == (ushort) 211)
|
|
newColor = new Color(50, (int) byte.MaxValue, 100, (int) byte.MaxValue);
|
|
this._dust[Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 43, Alpha: 254, newColor: newColor, Scale: 0.5f)].velocity *= 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EmitLivingTreeLeaf(int i, int j, int leafGoreType)
|
|
{
|
|
this.EmitLivingTreeLeaf_Below(i, j, leafGoreType);
|
|
if (this._rand.Next(2) != 0)
|
|
return;
|
|
this.EmitLivingTreeLeaf_Sideways(i, j, leafGoreType);
|
|
}
|
|
|
|
private void EmitLivingTreeLeaf_Below(int x, int y, int leafGoreType)
|
|
{
|
|
Tile testTile = Main.tile[x, y + 1];
|
|
if (WorldGen.SolidTile(testTile) || testTile.liquid > (byte) 0)
|
|
return;
|
|
float windForVisuals = Main.WindForVisuals;
|
|
if ((double) windForVisuals < -0.200000002980232 && (WorldGen.SolidTile(Main.tile[x - 1, y + 1]) || WorldGen.SolidTile(Main.tile[x - 2, y + 1])) || (double) windForVisuals > 0.200000002980232 && (WorldGen.SolidTile(Main.tile[x + 1, y + 1]) || WorldGen.SolidTile(Main.tile[x + 2, y + 1])))
|
|
return;
|
|
Gore.NewGorePerfect(new Vector2((float) (x * 16), (float) (y * 16 + 16)), Vector2.Zero, leafGoreType).Frame.CurrentColumn = Main.tile[x, y].color();
|
|
}
|
|
|
|
private void EmitLivingTreeLeaf_Sideways(int x, int y, int leafGoreType)
|
|
{
|
|
int num1 = 0;
|
|
if ((double) Main.WindForVisuals > 0.200000002980232)
|
|
num1 = 1;
|
|
else if ((double) Main.WindForVisuals < -0.200000002980232)
|
|
num1 = -1;
|
|
Tile testTile = Main.tile[x + num1, y];
|
|
if (WorldGen.SolidTile(testTile) || testTile.liquid > (byte) 0)
|
|
return;
|
|
int num2 = 0;
|
|
if (num1 == -1)
|
|
num2 = -10;
|
|
Gore.NewGorePerfect(new Vector2((float) (x * 16 + 8 + 4 * num1 + num2), (float) (y * 16 + 8)), Vector2.Zero, leafGoreType).Frame.CurrentColumn = Main.tile[x, y].color();
|
|
}
|
|
|
|
private void EmitLiquidDrops(int j, int i, Tile tileCache, ushort typeCache)
|
|
{
|
|
int num1 = 60;
|
|
switch (typeCache)
|
|
{
|
|
case 374:
|
|
num1 = 120;
|
|
break;
|
|
case 375:
|
|
num1 = 180;
|
|
break;
|
|
case 461:
|
|
num1 = 180;
|
|
break;
|
|
}
|
|
if (this._rand.Next(num1 * 2) != 0 || tileCache.liquid != (byte) 0)
|
|
return;
|
|
Rectangle rectangle1 = new Rectangle(i * 16, j * 16, 16, 16);
|
|
rectangle1.X -= 34;
|
|
rectangle1.Width += 68;
|
|
rectangle1.Y -= 100;
|
|
rectangle1.Height = 400;
|
|
bool flag = true;
|
|
for (int index = 0; index < 600; ++index)
|
|
{
|
|
if (this._gore[index].active && (this._gore[index].type >= 706 && this._gore[index].type <= 717 || this._gore[index].type == 943 || this._gore[index].type == 1147 || this._gore[index].type >= 1160 && this._gore[index].type <= 1162))
|
|
{
|
|
Rectangle rectangle2 = new Rectangle((int) this._gore[index].position.X, (int) this._gore[index].position.Y, 16, 16);
|
|
if (rectangle1.Intersects(rectangle2))
|
|
flag = false;
|
|
}
|
|
}
|
|
if (!flag)
|
|
return;
|
|
Vector2 Position = new Vector2((float) (i * 16), (float) (j * 16));
|
|
int num2 = 706;
|
|
if (Main.waterStyle == 12)
|
|
num2 = 1147;
|
|
else if (Main.waterStyle > 1)
|
|
num2 = 706 + Main.waterStyle - 1;
|
|
if (typeCache == (ushort) 374)
|
|
num2 = 716;
|
|
if (typeCache == (ushort) 375)
|
|
num2 = 717;
|
|
if (typeCache == (ushort) 461)
|
|
{
|
|
num2 = 943;
|
|
if (Main.player[Main.myPlayer].ZoneCorrupt)
|
|
num2 = 1160;
|
|
if (Main.player[Main.myPlayer].ZoneCrimson)
|
|
num2 = 1161;
|
|
if (Main.player[Main.myPlayer].ZoneHallow)
|
|
num2 = 1162;
|
|
}
|
|
Vector2 Velocity = new Vector2();
|
|
int Type = num2;
|
|
this._gore[Gore.NewGore(Position, Velocity, Type)].velocity *= 0.0f;
|
|
}
|
|
|
|
private float GetWindCycle(int x, int y, double windCounter)
|
|
{
|
|
if (!Main.SettingsEnabled_TilesSwayInWind)
|
|
return 0.0f;
|
|
float num1 = (float) ((double) x * 0.5 + (double) (y / 100) * 0.5);
|
|
float num2 = (float) Math.Cos(windCounter * 6.28318548202515 + (double) num1) * 0.5f;
|
|
return (double) y < Main.worldSurface ? (num2 + Main.WindForVisuals) * Utils.GetLerpValue(0.08f, 0.18f, Math.Abs(Main.WindForVisuals), true) : 0.0f;
|
|
}
|
|
|
|
private bool ShouldSwayInWind(int x, int y, Tile tileCache) => Main.SettingsEnabled_TilesSwayInWind && TileID.Sets.SwaysInWindBasic[(int) tileCache.type] && (tileCache.type != (ushort) 227 || tileCache.frameX != (short) 204 && tileCache.frameX != (short) 238 && tileCache.frameX != (short) 408 && tileCache.frameX != (short) 442 && tileCache.frameX != (short) 476);
|
|
|
|
private void UpdateLeafFrequency()
|
|
{
|
|
float num = Math.Abs(Main.WindForVisuals);
|
|
this._leafFrequency = (double) num > 0.100000001490116 ? ((double) num > 0.200000002980232 ? ((double) num > 0.300000011920929 ? ((double) num > 0.400000005960464 ? ((double) num > 0.5 ? ((double) num > 0.600000023841858 ? ((double) num > 0.699999988079071 ? ((double) num > 0.800000011920929 ? ((double) num > 0.899999976158142 ? ((double) num > 1.0 ? ((double) num > 1.10000002384186 ? 10 : 20) : 30) : 40) : 50) : 75) : 130) : 200) : 300) : 450) : 1000) : 2000;
|
|
this._leafFrequency *= 7;
|
|
}
|
|
|
|
private void EnsureWindGridSize()
|
|
{
|
|
Vector2 unscaledPosition = Main.Camera.UnscaledPosition;
|
|
Vector2 offSet = new Vector2((float) Main.offScreenRange, (float) Main.offScreenRange);
|
|
if (Main.drawToScreen)
|
|
offSet = Vector2.Zero;
|
|
int firstTileX;
|
|
int lastTileX;
|
|
int firstTileY;
|
|
int lastTileY;
|
|
this.GetScreenDrawArea(unscaledPosition, offSet, out firstTileX, out lastTileX, out firstTileY, out lastTileY);
|
|
this._windGrid.SetSize(lastTileX - firstTileX, lastTileY - firstTileY);
|
|
}
|
|
|
|
private void EmitTreeLeaves(int tilePosX, int tilePosY, int grassPosX, int grassPosY)
|
|
{
|
|
if (!this._isActiveAndNotPaused)
|
|
return;
|
|
int treeHeight = grassPosY - tilePosY;
|
|
Tile topTile = Main.tile[tilePosX, tilePosY];
|
|
if (topTile.liquid > (byte) 0)
|
|
return;
|
|
int passStyle;
|
|
WorldGen.GetTreeLeaf(tilePosX, topTile, Main.tile[grassPosX, grassPosY], ref treeHeight, out int _, out passStyle);
|
|
if (passStyle == -1 || passStyle == 912 || passStyle == 913)
|
|
return;
|
|
bool flag1 = passStyle >= 917 && passStyle <= 925 || passStyle >= 1113 && passStyle <= 1121;
|
|
int maxValue = this._leafFrequency;
|
|
bool flag2 = (uint) (tilePosX - grassPosX) > 0U;
|
|
if (flag1)
|
|
maxValue /= 2;
|
|
if ((double) tilePosY > Main.worldSurface)
|
|
maxValue = 10000;
|
|
if (flag2)
|
|
maxValue *= 3;
|
|
if (this._rand.Next(maxValue) != 0)
|
|
return;
|
|
int num1 = 2;
|
|
Vector2 vector2 = new Vector2((float) (tilePosX * 16 + 8), (float) (tilePosY * 16 + 8));
|
|
if (flag2)
|
|
{
|
|
int num2 = tilePosX - grassPosX;
|
|
vector2.X += (float) (num2 * 12);
|
|
int num3 = 0;
|
|
if (topTile.frameY == (short) 220)
|
|
num3 = 1;
|
|
else if (topTile.frameY == (short) 242)
|
|
num3 = 2;
|
|
if (topTile.frameX == (short) 66)
|
|
{
|
|
switch (num3)
|
|
{
|
|
case 0:
|
|
vector2 += new Vector2(0.0f, -6f);
|
|
break;
|
|
case 1:
|
|
vector2 += new Vector2(0.0f, -6f);
|
|
break;
|
|
case 2:
|
|
vector2 += new Vector2(0.0f, 8f);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (num3)
|
|
{
|
|
case 0:
|
|
vector2 += new Vector2(0.0f, 4f);
|
|
break;
|
|
case 1:
|
|
vector2 += new Vector2(2f, -6f);
|
|
break;
|
|
case 2:
|
|
vector2 += new Vector2(6f, -6f);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
vector2 += new Vector2(-16f, -16f);
|
|
if (flag1)
|
|
vector2.Y -= (float) (Main.rand.Next(0, 28) * 4);
|
|
}
|
|
if (WorldGen.SolidTile(vector2.ToTileCoordinates()))
|
|
return;
|
|
Gore.NewGoreDirect(vector2, Utils.RandomVector2(Main.rand, (float) -num1, (float) num1), passStyle, (float) (0.699999988079071 + (double) Main.rand.NextFloat() * 0.600000023841858)).Frame.CurrentColumn = Main.tile[tilePosX, tilePosY].color();
|
|
}
|
|
|
|
private void DrawSpecialTilesLegacy(Vector2 screenPosition, Vector2 offSet)
|
|
{
|
|
for (int index1 = 0; index1 < this._specialTilesCount; ++index1)
|
|
{
|
|
int index2 = this._specialTileX[index1];
|
|
int index3 = this._specialTileY[index1];
|
|
Tile tile = Main.tile[index2, index3];
|
|
ushort type1 = tile.type;
|
|
short frameX1 = tile.frameX;
|
|
short frameY1 = tile.frameY;
|
|
if (type1 == (ushort) 237)
|
|
Main.spriteBatch.Draw(TextureAssets.SunOrb.Value, new Vector2((float) (index2 * 16 - (int) screenPosition.X) + 8f, (float) (index3 * 16 - (int) screenPosition.Y - 36)) + offSet, new Rectangle?(new Rectangle(0, 0, TextureAssets.SunOrb.Width(), TextureAssets.SunOrb.Height())), new Color((int) Main.mouseTextColor, (int) Main.mouseTextColor, (int) Main.mouseTextColor, 0), Main.sunCircle, new Vector2((float) (TextureAssets.SunOrb.Width() / 2), (float) (TextureAssets.SunOrb.Height() / 2)), 1f, SpriteEffects.None, 0.0f);
|
|
if (type1 == (ushort) 334 && frameX1 >= (short) 5000)
|
|
{
|
|
int num1 = (int) frameY1 / 18;
|
|
int num2 = (int) frameX1;
|
|
int num3 = 0;
|
|
int type2 = num2 % 5000 - 100;
|
|
for (; num2 >= 5000; num2 -= 5000)
|
|
++num3;
|
|
int frameX2 = (int) Main.tile[index2 + 1, index3].frameX;
|
|
int pre = frameX2 < 25000 ? frameX2 - 10000 : frameX2 - 25000;
|
|
Item obj = new Item();
|
|
obj.netDefaults(type2);
|
|
obj.Prefix(pre);
|
|
Main.instance.LoadItem(obj.type);
|
|
Texture2D texture2D = TextureAssets.Item[obj.type].Value;
|
|
Rectangle rectangle = Main.itemAnimations[obj.type] == null ? texture2D.Frame() : Main.itemAnimations[obj.type].GetFrame(texture2D);
|
|
int width = rectangle.Width;
|
|
int height = rectangle.Height;
|
|
float num4 = 1f;
|
|
if (width > 40 || height > 40)
|
|
num4 = width <= height ? 40f / (float) height : 40f / (float) width;
|
|
float scale = num4 * obj.scale;
|
|
SpriteEffects effects = SpriteEffects.None;
|
|
if (num3 >= 3)
|
|
effects = SpriteEffects.FlipHorizontally;
|
|
Color color = Lighting.GetColor(index2, index3);
|
|
Main.spriteBatch.Draw(texture2D, new Vector2((float) (index2 * 16 - (int) screenPosition.X + 24), (float) (index3 * 16 - (int) screenPosition.Y + 8)) + offSet, new Rectangle?(rectangle), Lighting.GetColor(index2, index3), 0.0f, new Vector2((float) (width / 2), (float) (height / 2)), scale, effects, 0.0f);
|
|
if (obj.color != new Color())
|
|
Main.spriteBatch.Draw(texture2D, new Vector2((float) (index2 * 16 - (int) screenPosition.X + 24), (float) (index3 * 16 - (int) screenPosition.Y + 8)) + offSet, new Rectangle?(rectangle), obj.GetColor(color), 0.0f, new Vector2((float) (width / 2), (float) (height / 2)), scale, effects, 0.0f);
|
|
}
|
|
if (type1 == (ushort) 395)
|
|
{
|
|
Item theItem = ((TEItemFrame) TileEntity.ByPosition[new Point16(index2, index3)]).item;
|
|
Vector2 screenPositionForItemCenter = new Vector2((float) (index2 * 16 - (int) screenPosition.X + 16), (float) (index3 * 16 - (int) screenPosition.Y + 16)) + offSet;
|
|
Color color = Lighting.GetColor(index2, index3);
|
|
Main.DrawItemIcon(Main.spriteBatch, theItem, screenPositionForItemCenter, color, 20f);
|
|
}
|
|
if (type1 == (ushort) 520)
|
|
{
|
|
Item obj = ((TEFoodPlatter) TileEntity.ByPosition[new Point16(index2, index3)]).item;
|
|
if (!obj.IsAir)
|
|
{
|
|
Main.instance.LoadItem(obj.type);
|
|
Texture2D texture2D = TextureAssets.Item[obj.type].Value;
|
|
Rectangle rectangle = !ItemID.Sets.IsFood[obj.type] ? texture2D.Frame() : texture2D.Frame(verticalFrames: 3, frameY: 2);
|
|
int width = rectangle.Width;
|
|
int height = rectangle.Height;
|
|
float num = 1f;
|
|
SpriteEffects effects = tile.frameX == (short) 0 ? SpriteEffects.FlipHorizontally : SpriteEffects.None;
|
|
Color color = Lighting.GetColor(index2, index3);
|
|
Color currentColor = color;
|
|
float scale1 = 1f;
|
|
ItemSlot.GetItemLight(ref currentColor, ref scale1, obj);
|
|
float scale2 = num * scale1;
|
|
Vector2 position = new Vector2((float) (index2 * 16 - (int) screenPosition.X + 8), (float) (index3 * 16 - (int) screenPosition.Y + 16)) + offSet;
|
|
position.Y += 2f;
|
|
Vector2 origin = new Vector2((float) (width / 2), (float) height);
|
|
Main.spriteBatch.Draw(texture2D, position, new Rectangle?(rectangle), currentColor, 0.0f, origin, scale2, effects, 0.0f);
|
|
if (obj.color != new Color())
|
|
Main.spriteBatch.Draw(texture2D, position, new Rectangle?(rectangle), obj.GetColor(color), 0.0f, origin, scale2, effects, 0.0f);
|
|
}
|
|
}
|
|
if (type1 == (ushort) 471)
|
|
{
|
|
Item obj = (TileEntity.ByPosition[new Point16(index2, index3)] as TEWeaponsRack).item;
|
|
Main.instance.LoadItem(obj.type);
|
|
Texture2D texture2D = TextureAssets.Item[obj.type].Value;
|
|
Rectangle rectangle = Main.itemAnimations[obj.type] == null ? texture2D.Frame() : Main.itemAnimations[obj.type].GetFrame(texture2D);
|
|
int width = rectangle.Width;
|
|
int height = rectangle.Height;
|
|
float num5 = 1f;
|
|
float num6 = 40f;
|
|
if ((double) width > (double) num6 || (double) height > (double) num6)
|
|
num5 = width <= height ? num6 / (float) height : num6 / (float) width;
|
|
float num7 = num5 * obj.scale;
|
|
SpriteEffects effects = SpriteEffects.FlipHorizontally;
|
|
if (tile.frameX < (short) 54)
|
|
effects = SpriteEffects.None;
|
|
Color color = Lighting.GetColor(index2, index3);
|
|
Color currentColor = color;
|
|
float scale3 = 1f;
|
|
ItemSlot.GetItemLight(ref currentColor, ref scale3, obj);
|
|
float scale4 = num7 * scale3;
|
|
Main.spriteBatch.Draw(texture2D, new Vector2((float) (index2 * 16 - (int) screenPosition.X + 24), (float) (index3 * 16 - (int) screenPosition.Y + 24)) + offSet, new Rectangle?(rectangle), currentColor, 0.0f, new Vector2((float) (width / 2), (float) (height / 2)), scale4, effects, 0.0f);
|
|
if (obj.color != new Color())
|
|
Main.spriteBatch.Draw(texture2D, new Vector2((float) (index2 * 16 - (int) screenPosition.X + 24), (float) (index3 * 16 - (int) screenPosition.Y + 24)) + offSet, new Rectangle?(rectangle), obj.GetColor(color), 0.0f, new Vector2((float) (width / 2), (float) (height / 2)), scale4, effects, 0.0f);
|
|
}
|
|
if (type1 == (ushort) 412)
|
|
{
|
|
Texture2D texture2D = TextureAssets.GlowMask[202].Value;
|
|
int frameY2 = Main.tileFrame[(int) type1] / 60;
|
|
int frameY3 = (frameY2 + 1) % 4;
|
|
float num = (float) (Main.tileFrame[(int) type1] % 60) / 60f;
|
|
Color color = new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue);
|
|
Main.spriteBatch.Draw(texture2D, new Vector2((float) (index2 * 16 - (int) screenPosition.X), (float) (index3 * 16 - (int) screenPosition.Y + 10)) + offSet, new Rectangle?(texture2D.Frame(verticalFrames: 4, frameY: frameY2)), color * (1f - num), 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
Main.spriteBatch.Draw(texture2D, new Vector2((float) (index2 * 16 - (int) screenPosition.X), (float) (index3 * 16 - (int) screenPosition.Y + 10)) + offSet, new Rectangle?(texture2D.Frame(verticalFrames: 4, frameY: frameY3)), color * num, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
if (type1 == (ushort) 620)
|
|
{
|
|
Texture2D texture = TextureAssets.Extra[202].Value;
|
|
double num8 = (double) (Main.tileFrame[(int) type1] % 60) / 60.0;
|
|
int num9 = 2;
|
|
Main.critterCage = true;
|
|
int waterAnimalCageFrame = this.GetWaterAnimalCageFrame(index2, index3, (int) frameX1, (int) frameY1);
|
|
int index4 = 8;
|
|
int num10 = Main.butterflyCageFrame[index4, waterAnimalCageFrame];
|
|
int num11 = 6;
|
|
float num12 = 1f;
|
|
Rectangle rectangle = new Rectangle(0, 34 * num10, 32, 32);
|
|
Vector2 position1 = new Vector2((float) (index2 * 16 - (int) screenPosition.X), (float) (index3 * 16 - (int) screenPosition.Y + num9)) + offSet;
|
|
Main.spriteBatch.Draw(texture, position1, new Rectangle?(rectangle), new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue), 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
for (int index5 = 0; index5 < num11; ++index5)
|
|
{
|
|
Color color = new Color((int) sbyte.MaxValue, (int) sbyte.MaxValue, (int) sbyte.MaxValue, 0).MultiplyRGBA(Main.hslToRgb((float) (((double) Main.GlobalTimeWrappedHourly + (double) index5 / (double) num11) % 1.0), 1f, 0.5f)) * (float) (1.0 - (double) num12 * 0.5);
|
|
color.A = (byte) 0;
|
|
int num13 = 2;
|
|
Vector2 position2 = position1 + ((float) ((double) index5 / (double) num11 * 6.28318548202515)).ToRotationVector2() * (float) ((double) num13 * (double) num12 + 2.0);
|
|
Main.spriteBatch.Draw(texture, position2, new Rectangle?(rectangle), color, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
Main.spriteBatch.Draw(texture, position1, new Rectangle?(rectangle), new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, 0) * 0.1f, 0.0f, Vector2.Zero, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawEntities_DisplayDolls()
|
|
{
|
|
Main.spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, Main.DefaultSamplerState, DepthStencilState.None, Main.Rasterizer, (Effect) null, Main.Transform);
|
|
foreach (KeyValuePair<Point, int> tileEntityPosition in this._displayDollTileEntityPositions)
|
|
{
|
|
TileEntity tileEntity;
|
|
if (tileEntityPosition.Value != -1 && TileEntity.ByPosition.TryGetValue(new Point16(tileEntityPosition.Key.X, tileEntityPosition.Key.Y), out tileEntity))
|
|
(tileEntity as TEDisplayDoll).Draw(tileEntityPosition.Key.X, tileEntityPosition.Key.Y);
|
|
}
|
|
Main.spriteBatch.End();
|
|
}
|
|
|
|
private void DrawEntities_HatRacks()
|
|
{
|
|
Main.spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend, Main.DefaultSamplerState, DepthStencilState.None, Main.Rasterizer, (Effect) null, Main.Transform);
|
|
foreach (KeyValuePair<Point, int> tileEntityPosition in this._hatRackTileEntityPositions)
|
|
{
|
|
TileEntity tileEntity;
|
|
if (tileEntityPosition.Value != -1 && TileEntity.ByPosition.TryGetValue(new Point16(tileEntityPosition.Key.X, tileEntityPosition.Key.Y), out tileEntity))
|
|
(tileEntity as TEHatRack).Draw(tileEntityPosition.Key.X, tileEntityPosition.Key.Y);
|
|
}
|
|
Main.spriteBatch.End();
|
|
}
|
|
|
|
private void DrawTrees()
|
|
{
|
|
Vector2 unscaledPosition = Main.Camera.UnscaledPosition;
|
|
Vector2 zero = Vector2.Zero;
|
|
int index1 = 0;
|
|
int num1 = this._specialsCount[index1];
|
|
float num2 = 0.08f;
|
|
float num3 = 0.06f;
|
|
for (int index2 = 0; index2 < num1; ++index2)
|
|
{
|
|
Point point = this._specialPositions[index1][index2];
|
|
int x = point.X;
|
|
int y1 = point.Y;
|
|
Tile t = Main.tile[x, y1];
|
|
if (t != null && t.active())
|
|
{
|
|
ushort type = t.type;
|
|
short frameX = t.frameX;
|
|
short frameY1 = t.frameY;
|
|
bool flag1 = t.wall > (ushort) 0;
|
|
WorldGen.GetTreeFoliageDataMethod foliageDataMethod = (WorldGen.GetTreeFoliageDataMethod) null;
|
|
try
|
|
{
|
|
bool flag2 = false;
|
|
switch (type)
|
|
{
|
|
case 5:
|
|
flag2 = true;
|
|
foliageDataMethod = new WorldGen.GetTreeFoliageDataMethod(WorldGen.GetCommonTreeFoliageData);
|
|
break;
|
|
case 583:
|
|
case 584:
|
|
case 585:
|
|
case 586:
|
|
case 587:
|
|
case 588:
|
|
case 589:
|
|
flag2 = true;
|
|
foliageDataMethod = new WorldGen.GetTreeFoliageDataMethod(WorldGen.GetGemTreeFoliageData);
|
|
break;
|
|
case 596:
|
|
case 616:
|
|
flag2 = true;
|
|
foliageDataMethod = new WorldGen.GetTreeFoliageDataMethod(WorldGen.GetVanityTreeFoliageData);
|
|
break;
|
|
}
|
|
if (flag2 && frameY1 >= (short) 198 && frameX >= (short) 22)
|
|
{
|
|
int treeFrame = WorldGen.GetTreeFrame(t);
|
|
switch (frameX)
|
|
{
|
|
case 22:
|
|
int treeStyle1 = 0;
|
|
int topTextureFrameWidth1 = 80;
|
|
int topTextureFrameHeight1 = 80;
|
|
int xoffset1 = 0;
|
|
int grassPosX = x + xoffset1;
|
|
int floorY1 = y1;
|
|
if (foliageDataMethod(x, y1, xoffset1, ref treeFrame, ref treeStyle1, out floorY1, out topTextureFrameWidth1, out topTextureFrameHeight1))
|
|
{
|
|
this.EmitTreeLeaves(x, y1, grassPosX, floorY1);
|
|
if (treeStyle1 == 14)
|
|
{
|
|
float num4 = (float) this._rand.Next(28, 42) * 0.005f + (float) (270 - (int) Main.mouseTextColor) / 1000f;
|
|
Lighting.AddLight(x, y1, 0.1f, (float) (0.200000002980232 + (double) num4 / 2.0), 0.7f + num4);
|
|
}
|
|
byte tileColor = t.color();
|
|
Texture2D treeTopTexture = this.GetTreeTopTexture(treeStyle1, 0, tileColor);
|
|
Vector2 vector2;
|
|
Vector2 position = vector2 = new Vector2((float) (x * 16 - (int) unscaledPosition.X + 8), (float) (y1 * 16 - (int) unscaledPosition.Y + 16)) + zero;
|
|
float num5 = 0.0f;
|
|
if (!flag1)
|
|
num5 = this.GetWindCycle(x, y1, this._treeWindCounter);
|
|
position.X += num5 * 2f;
|
|
position.Y += Math.Abs(num5) * 2f;
|
|
Color color = Lighting.GetColor(x, y1);
|
|
if (t.color() == (byte) 31)
|
|
color = Color.White;
|
|
Main.spriteBatch.Draw(treeTopTexture, position, new Rectangle?(new Rectangle(treeFrame * (topTextureFrameWidth1 + 2), 0, topTextureFrameWidth1, topTextureFrameHeight1)), color, num5 * num2, new Vector2((float) (topTextureFrameWidth1 / 2), (float) topTextureFrameHeight1), 1f, SpriteEffects.None, 0.0f);
|
|
break;
|
|
}
|
|
continue;
|
|
case 44:
|
|
int treeStyle2 = 0;
|
|
int num6 = x;
|
|
int floorY2 = y1;
|
|
int xoffset2 = 1;
|
|
int topTextureFrameWidth2;
|
|
int topTextureFrameHeight2;
|
|
if (foliageDataMethod(x, y1, xoffset2, ref treeFrame, ref treeStyle2, out floorY2, out topTextureFrameWidth2, out topTextureFrameHeight2))
|
|
{
|
|
this.EmitTreeLeaves(x, y1, num6 + xoffset2, floorY2);
|
|
if (treeStyle2 == 14)
|
|
{
|
|
float num7 = (float) this._rand.Next(28, 42) * 0.005f + (float) (270 - (int) Main.mouseTextColor) / 1000f;
|
|
Lighting.AddLight(x, y1, 0.1f, (float) (0.200000002980232 + (double) num7 / 2.0), 0.7f + num7);
|
|
}
|
|
byte tileColor = t.color();
|
|
Texture2D treeBranchTexture = this.GetTreeBranchTexture(treeStyle2, 0, tileColor);
|
|
Vector2 position = new Vector2((float) (x * 16), (float) (y1 * 16)) - unscaledPosition.Floor() + zero + new Vector2(16f, 12f);
|
|
float num8 = 0.0f;
|
|
if (!flag1)
|
|
num8 = this.GetWindCycle(x, y1, this._treeWindCounter);
|
|
if ((double) num8 > 0.0)
|
|
position.X += num8;
|
|
position.X += Math.Abs(num8) * 2f;
|
|
Color color = Lighting.GetColor(x, y1);
|
|
if (t.color() == (byte) 31)
|
|
color = Color.White;
|
|
Main.spriteBatch.Draw(treeBranchTexture, position, new Rectangle?(new Rectangle(0, treeFrame * 42, 40, 40)), color, num8 * num3, new Vector2(40f, 24f), 1f, SpriteEffects.None, 0.0f);
|
|
break;
|
|
}
|
|
continue;
|
|
case 66:
|
|
int treeStyle3 = 0;
|
|
int num9 = x;
|
|
int floorY3 = y1;
|
|
int xoffset3 = -1;
|
|
int topTextureFrameWidth3;
|
|
int topTextureFrameHeight3;
|
|
if (foliageDataMethod(x, y1, xoffset3, ref treeFrame, ref treeStyle3, out floorY3, out topTextureFrameWidth3, out topTextureFrameHeight3))
|
|
{
|
|
this.EmitTreeLeaves(x, y1, num9 + xoffset3, floorY3);
|
|
if (treeStyle3 == 14)
|
|
{
|
|
float num10 = (float) this._rand.Next(28, 42) * 0.005f + (float) (270 - (int) Main.mouseTextColor) / 1000f;
|
|
Lighting.AddLight(x, y1, 0.1f, (float) (0.200000002980232 + (double) num10 / 2.0), 0.7f + num10);
|
|
}
|
|
byte tileColor = t.color();
|
|
Texture2D treeBranchTexture = this.GetTreeBranchTexture(treeStyle3, 0, tileColor);
|
|
Vector2 position = new Vector2((float) (x * 16), (float) (y1 * 16)) - unscaledPosition.Floor() + zero + new Vector2(0.0f, 18f);
|
|
float num11 = 0.0f;
|
|
if (!flag1)
|
|
num11 = this.GetWindCycle(x, y1, this._treeWindCounter);
|
|
if ((double) num11 < 0.0)
|
|
position.X += num11;
|
|
position.X -= Math.Abs(num11) * 2f;
|
|
Color color = Lighting.GetColor(x, y1);
|
|
if (t.color() == (byte) 31)
|
|
color = Color.White;
|
|
Main.spriteBatch.Draw(treeBranchTexture, position, new Rectangle?(new Rectangle(42, treeFrame * 42, 40, 40)), color, num11 * num3, new Vector2(0.0f, 30f), 1f, SpriteEffects.None, 0.0f);
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
if (type == (ushort) 323)
|
|
{
|
|
if (frameX >= (short) 88)
|
|
{
|
|
if (frameX <= (short) 132)
|
|
{
|
|
int num12 = 0;
|
|
if (frameX == (short) 110)
|
|
num12 = 1;
|
|
else if (frameX == (short) 132)
|
|
num12 = 2;
|
|
int treeTextureIndex = 15;
|
|
int width = 80;
|
|
int height = 80;
|
|
int num13 = 32;
|
|
int num14 = 0;
|
|
int palmTreeBiome = this.GetPalmTreeBiome(x, y1);
|
|
int y2 = palmTreeBiome * 82;
|
|
if (palmTreeBiome >= 4 && palmTreeBiome <= 7)
|
|
{
|
|
treeTextureIndex = 21;
|
|
width = 114;
|
|
height = 98;
|
|
y2 = (palmTreeBiome - 4) * 98;
|
|
num13 = 48;
|
|
num14 = 2;
|
|
}
|
|
int frameY2 = (int) Main.tile[x, y1].frameY;
|
|
byte tileColor = t.color();
|
|
Texture2D treeTopTexture = this.GetTreeTopTexture(treeTextureIndex, palmTreeBiome, tileColor);
|
|
Vector2 position = new Vector2((float) (x * 16 - (int) unscaledPosition.X - num13 + frameY2 + width / 2), (float) (y1 * 16 - (int) unscaledPosition.Y + 16 + num14)) + zero;
|
|
float num15 = 0.0f;
|
|
if (!flag1)
|
|
num15 = this.GetWindCycle(x, y1, this._treeWindCounter);
|
|
position.X += num15 * 2f;
|
|
position.Y += Math.Abs(num15) * 2f;
|
|
Color color = Lighting.GetColor(x, y1);
|
|
if (t.color() == (byte) 31)
|
|
color = Color.White;
|
|
Main.spriteBatch.Draw(treeTopTexture, position, new Rectangle?(new Rectangle(num12 * (width + 2), y2, width, height)), color, num15 * num2, new Vector2((float) (width / 2), (float) height), 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private Texture2D GetTreeTopTexture(
|
|
int treeTextureIndex,
|
|
int treeTextureStyle,
|
|
byte tileColor)
|
|
{
|
|
return this._paintSystem.TryGetTreeTopAndRequestIfNotReady(treeTextureIndex, treeTextureStyle, (int) tileColor) ?? TextureAssets.TreeTop[treeTextureIndex].Value;
|
|
}
|
|
|
|
private Texture2D GetTreeBranchTexture(
|
|
int treeTextureIndex,
|
|
int treeTextureStyle,
|
|
byte tileColor)
|
|
{
|
|
return this._paintSystem.TryGetTreeBranchAndRequestIfNotReady(treeTextureIndex, treeTextureStyle, (int) tileColor) ?? TextureAssets.TreeBranch[treeTextureIndex].Value;
|
|
}
|
|
|
|
private void DrawGrass()
|
|
{
|
|
Vector2 unscaledPosition = Main.Camera.UnscaledPosition;
|
|
Vector2 zero = Vector2.Zero;
|
|
int index1 = 3;
|
|
int num1 = this._specialsCount[index1];
|
|
for (int index2 = 0; index2 < num1; ++index2)
|
|
{
|
|
Point point = this._specialPositions[index1][index2];
|
|
int x = point.X;
|
|
int y = point.Y;
|
|
Tile tile = Main.tile[x, y];
|
|
if (tile != null && tile.active())
|
|
{
|
|
ushort type = tile.type;
|
|
short frameX = tile.frameX;
|
|
short frameY = tile.frameY;
|
|
int tileWidth;
|
|
int tileHeight;
|
|
int tileTop;
|
|
int halfBrickHeight;
|
|
int addFrX;
|
|
int addFrY;
|
|
SpriteEffects tileSpriteEffect;
|
|
this.GetTileDrawData(x, y, tile, type, ref frameX, ref frameY, out tileWidth, out tileHeight, out tileTop, out halfBrickHeight, out addFrX, out addFrY, out tileSpriteEffect, out Texture2D _, out Rectangle _, out Color _);
|
|
bool canDoDust = this._rand.Next(4) == 0;
|
|
Color tileLight = Lighting.GetColor(x, y);
|
|
this.DrawAnimatedTile_AdjustForVisionChangers(x, y, tile, type, frameX, frameY, ref tileLight, canDoDust);
|
|
tileLight = this.DrawTiles_GetLightOverride(y, x, tile, type, frameX, frameY, tileLight);
|
|
if (this._isActiveAndNotPaused & canDoDust)
|
|
this.DrawTiles_EmitParticles(y, x, tile, type, frameX, frameY, tileLight);
|
|
if (type == (ushort) 83 && this.IsAlchemyPlantHarvestable((int) frameX / 18))
|
|
{
|
|
ushort num2 = 84;
|
|
Main.instance.LoadTiles((int) num2);
|
|
}
|
|
if (tile.type == (ushort) 227 && frameX == (short) 202)
|
|
{
|
|
bool evil;
|
|
bool good;
|
|
bool crimson;
|
|
this.GetCactusType(x, y, (int) frameX, (int) frameY, out evil, out good, out crimson);
|
|
if (good)
|
|
frameX += (short) 170;
|
|
if (evil)
|
|
frameX += (short) 204;
|
|
if (crimson)
|
|
frameX += (short) 238;
|
|
}
|
|
Vector2 position = new Vector2((float) (x * 16 - (int) unscaledPosition.X + 8), (float) (y * 16 - (int) unscaledPosition.Y + 16)) + zero;
|
|
double grassWindCounter = this._grassWindCounter;
|
|
float num3 = this.GetWindCycle(x, y, this._grassWindCounter);
|
|
if (!WallID.Sets.AllowsWind[(int) tile.wall])
|
|
num3 = 0.0f;
|
|
if (!this.InAPlaceWithWind(x, y, 1, 1))
|
|
num3 = 0.0f;
|
|
float num4 = num3 + this.GetWindGridPush(x, y, 20, 0.35f);
|
|
position.X += num4 * 1f;
|
|
position.Y += Math.Abs(num4) * 1f;
|
|
Texture2D tileDrawTexture = this.GetTileDrawTexture(tile, x, y);
|
|
if (tileDrawTexture != null)
|
|
Main.spriteBatch.Draw(tileDrawTexture, position, new Rectangle?(new Rectangle((int) frameX + addFrX, (int) frameY + addFrY, tileWidth, tileHeight - halfBrickHeight)), tileLight, num4 * 0.1f, new Vector2((float) (tileWidth / 2), (float) (16 - halfBrickHeight - tileTop)), 1f, tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawAnimatedTile_AdjustForVisionChangers(
|
|
int i,
|
|
int j,
|
|
Tile tileCache,
|
|
ushort typeCache,
|
|
short tileFrameX,
|
|
short tileFrameY,
|
|
ref Color tileLight,
|
|
bool canDoDust)
|
|
{
|
|
if (this._localPlayer.dangerSense && TileDrawing.IsTileDangerous(this._localPlayer, tileCache, typeCache))
|
|
{
|
|
if (tileLight.R < byte.MaxValue)
|
|
tileLight.R = byte.MaxValue;
|
|
if (tileLight.G < (byte) 50)
|
|
tileLight.G = (byte) 50;
|
|
if (tileLight.B < (byte) 50)
|
|
tileLight.B = (byte) 50;
|
|
if (this._isActiveAndNotPaused & canDoDust && this._rand.Next(30) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 60, Alpha: 100, Scale: 0.3f);
|
|
this._dust[index].fadeIn = 1f;
|
|
this._dust[index].velocity *= 0.1f;
|
|
this._dust[index].noLight = true;
|
|
this._dust[index].noGravity = true;
|
|
}
|
|
}
|
|
if (!this._localPlayer.findTreasure || !Main.IsTileSpelunkable(typeCache, tileFrameX, tileFrameY))
|
|
return;
|
|
if (tileLight.R < (byte) 200)
|
|
tileLight.R = (byte) 200;
|
|
if (tileLight.G < (byte) 170)
|
|
tileLight.G = (byte) 170;
|
|
if (!this._isActiveAndNotPaused || !(this._rand.Next(60) == 0 & canDoDust))
|
|
return;
|
|
int index1 = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 204, Alpha: 150, Scale: 0.3f);
|
|
this._dust[index1].fadeIn = 1f;
|
|
this._dust[index1].velocity *= 0.1f;
|
|
this._dust[index1].noLight = true;
|
|
}
|
|
|
|
private float GetWindGridPush(
|
|
int i,
|
|
int j,
|
|
int pushAnimationTimeTotal,
|
|
float pushForcePerFrame)
|
|
{
|
|
int windTimeLeft;
|
|
int direction;
|
|
this._windGrid.GetWindTime(i, j, pushAnimationTimeTotal, out windTimeLeft, out direction);
|
|
return windTimeLeft >= pushAnimationTimeTotal / 2 ? (float) (pushAnimationTimeTotal - windTimeLeft) * pushForcePerFrame * (float) direction : (float) windTimeLeft * pushForcePerFrame * (float) direction;
|
|
}
|
|
|
|
private float GetWindGridPushComplex(
|
|
int i,
|
|
int j,
|
|
int pushAnimationTimeTotal,
|
|
float totalPushForce,
|
|
int loops,
|
|
bool flipDirectionPerLoop)
|
|
{
|
|
int windTimeLeft;
|
|
int direction;
|
|
this._windGrid.GetWindTime(i, j, pushAnimationTimeTotal, out windTimeLeft, out direction);
|
|
double num1 = (double) windTimeLeft / (double) pushAnimationTimeTotal;
|
|
int num2 = (int) (num1 * (double) loops);
|
|
float num3 = (float) (num1 * (double) loops % 1.0);
|
|
double num4 = 1.0 / (double) loops;
|
|
if (flipDirectionPerLoop && num2 % 2 == 1)
|
|
direction *= -1;
|
|
return num1 * (double) loops % 1.0 > 0.5 ? (1f - num3) * totalPushForce * (float) direction * (float) (loops - num2) : num3 * totalPushForce * (float) direction * (float) (loops - num2);
|
|
}
|
|
|
|
private void DrawMasterTrophies()
|
|
{
|
|
int index1 = 11;
|
|
int num1 = this._specialsCount[index1];
|
|
for (int index2 = 0; index2 < num1; ++index2)
|
|
{
|
|
Point p = this._specialPositions[index1][index2];
|
|
Tile tile = Main.tile[p.X, p.Y];
|
|
if (tile != null && tile.active())
|
|
{
|
|
Texture2D texture2D = TextureAssets.Extra[198].Value;
|
|
int frameY = (int) tile.frameX / 54;
|
|
int num2 = (uint) tile.frameY / 72U > 0U ? 1 : 0;
|
|
int horizontalFrames = 1;
|
|
int verticalFrames = 27;
|
|
Rectangle r = texture2D.Frame(horizontalFrames, verticalFrames, frameY: frameY);
|
|
Vector2 origin = r.Size() / 2f;
|
|
Vector2 worldCoordinates = p.ToWorldCoordinates(24f, 64f);
|
|
float num3 = (float) Math.Sin((double) Main.GlobalTimeWrappedHourly * 6.28318548202515 / 5.0);
|
|
Vector2 vector2_1 = new Vector2(0.0f, -40f);
|
|
Vector2 vector2_2 = worldCoordinates + vector2_1 + new Vector2(0.0f, num3 * 4f);
|
|
Color color1 = Lighting.GetColor(p.X, p.Y);
|
|
SpriteEffects effects = num2 != 0 ? SpriteEffects.FlipHorizontally : SpriteEffects.None;
|
|
Main.spriteBatch.Draw(texture2D, vector2_2 - Main.screenPosition, new Rectangle?(r), color1, 0.0f, origin, 1f, effects, 0.0f);
|
|
float num4 = (float) (Math.Sin((double) Main.GlobalTimeWrappedHourly * 6.28318548202515 / 2.0) * 0.300000011920929 + 0.699999988079071);
|
|
Color color2 = color1;
|
|
color2.A = (byte) 0;
|
|
Color color3 = color2 * 0.1f * num4;
|
|
for (float num5 = 0.0f; (double) num5 < 1.0; num5 += 0.1666667f)
|
|
Main.spriteBatch.Draw(texture2D, vector2_2 - Main.screenPosition + (6.283185f * num5).ToRotationVector2() * (float) (6.0 + (double) num3 * 2.0), new Rectangle?(r), color3, 0.0f, origin, 1f, effects, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawTeleportationPylons()
|
|
{
|
|
int index1 = 10;
|
|
int num1 = this._specialsCount[index1];
|
|
for (int index2 = 0; index2 < num1; ++index2)
|
|
{
|
|
Point p = this._specialPositions[index1][index2];
|
|
Tile tile = Main.tile[p.X, p.Y];
|
|
if (tile != null && tile.active())
|
|
{
|
|
Texture2D texture2D = TextureAssets.Extra[181].Value;
|
|
int tileStyle = (int) tile.frameX / 54;
|
|
int num2 = 3;
|
|
int horizontalFrames = num2 + 9;
|
|
int verticalFrames = 8;
|
|
int frameY = (Main.tileFrameCounter[597] + p.X + p.Y) % 64 / 8;
|
|
Rectangle r = texture2D.Frame(horizontalFrames, verticalFrames, num2 + tileStyle, frameY);
|
|
Rectangle rectangle = texture2D.Frame(horizontalFrames, verticalFrames, 2, frameY);
|
|
texture2D.Frame(horizontalFrames, verticalFrames, frameY: frameY);
|
|
Vector2 origin = r.Size() / 2f;
|
|
Vector2 worldCoordinates = p.ToWorldCoordinates(24f, 64f);
|
|
float num3 = (float) Math.Sin((double) Main.GlobalTimeWrappedHourly * 6.28318548202515 / 5.0);
|
|
Vector2 vector2 = new Vector2(0.0f, -40f);
|
|
Vector2 center = worldCoordinates + vector2 + new Vector2(0.0f, num3 * 4f);
|
|
if (this._isActiveAndNotPaused & this._rand.Next(4) == 0 && this._rand.Next(10) == 0)
|
|
{
|
|
Rectangle dustBox = Utils.CenteredRectangle(center, r.Size());
|
|
TeleportPylonsSystem.SpawnInWorldDust(tileStyle, dustBox);
|
|
}
|
|
Color color1 = Color.Lerp(Lighting.GetColor(p.X, p.Y), Color.White, 0.8f);
|
|
Main.spriteBatch.Draw(texture2D, center - Main.screenPosition, new Rectangle?(r), color1 * 0.7f, 0.0f, origin, 1f, SpriteEffects.None, 0.0f);
|
|
Color color2 = new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, 0) * 0.1f * (float) (Math.Sin((double) Main.GlobalTimeWrappedHourly * 6.28318548202515 / 1.0) * 0.200000002980232 + 0.800000011920929);
|
|
for (float num4 = 0.0f; (double) num4 < 1.0; num4 += 0.1666667f)
|
|
Main.spriteBatch.Draw(texture2D, center - Main.screenPosition + (6.283185f * num4).ToRotationVector2() * (float) (6.0 + (double) num3 * 2.0), new Rectangle?(r), color2, 0.0f, origin, 1f, SpriteEffects.None, 0.0f);
|
|
int num5 = 0;
|
|
bool actuallySelected;
|
|
if (Main.InSmartCursorHighlightArea(p.X, p.Y, out actuallySelected))
|
|
{
|
|
num5 = 1;
|
|
if (actuallySelected)
|
|
num5 = 2;
|
|
}
|
|
if (num5 != 0)
|
|
{
|
|
int averageTileLighting = ((int) color1.R + (int) color1.G + (int) color1.B) / 3;
|
|
if (averageTileLighting > 10)
|
|
{
|
|
Color selectionGlowColor = Colors.GetSelectionGlowColor(num5 == 2, averageTileLighting);
|
|
Main.spriteBatch.Draw(texture2D, center - Main.screenPosition, new Rectangle?(rectangle), selectionGlowColor, 0.0f, origin, 1f, SpriteEffects.None, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawVoidLenses()
|
|
{
|
|
int index1 = 8;
|
|
int num = this._specialsCount[index1];
|
|
this._voidLensData.Clear();
|
|
for (int index2 = 0; index2 < num; ++index2)
|
|
{
|
|
Point p = this._specialPositions[index1][index2];
|
|
VoidLensHelper voidLensHelper = new VoidLensHelper(p.ToWorldCoordinates(), 1f);
|
|
if (!Main.gamePaused)
|
|
voidLensHelper.Update();
|
|
int selectionMode = 0;
|
|
bool actuallySelected;
|
|
if (Main.InSmartCursorHighlightArea(p.X, p.Y, out actuallySelected))
|
|
{
|
|
selectionMode = 1;
|
|
if (actuallySelected)
|
|
selectionMode = 2;
|
|
}
|
|
voidLensHelper.DrawToDrawData(this._voidLensData, selectionMode);
|
|
}
|
|
foreach (DrawData drawData in this._voidLensData)
|
|
drawData.Draw(Main.spriteBatch);
|
|
}
|
|
|
|
private void DrawMultiTileGrass()
|
|
{
|
|
Vector2 unscaledPosition = Main.Camera.UnscaledPosition;
|
|
Vector2 zero = Vector2.Zero;
|
|
int index1 = 4;
|
|
int num = this._specialsCount[index1];
|
|
for (int index2 = 0; index2 < num; ++index2)
|
|
{
|
|
Point point = this._specialPositions[index1][index2];
|
|
int x = point.X;
|
|
int y = point.Y;
|
|
int sizeX = 1;
|
|
int sizeY = 1;
|
|
Tile tile = Main.tile[x, y];
|
|
if (tile != null && tile.active())
|
|
{
|
|
switch (Main.tile[x, y].type)
|
|
{
|
|
case 27:
|
|
sizeX = 2;
|
|
sizeY = 5;
|
|
break;
|
|
case 233:
|
|
sizeX = Main.tile[x, y].frameY != (short) 0 ? 2 : 3;
|
|
sizeY = 2;
|
|
break;
|
|
case 236:
|
|
case 238:
|
|
sizeX = sizeY = 2;
|
|
break;
|
|
case 485:
|
|
case 490:
|
|
case 521:
|
|
case 522:
|
|
case 523:
|
|
case 524:
|
|
case 525:
|
|
case 526:
|
|
case 527:
|
|
sizeX = 2;
|
|
sizeY = 2;
|
|
break;
|
|
case 489:
|
|
sizeX = 2;
|
|
sizeY = 3;
|
|
break;
|
|
case 493:
|
|
sizeX = 1;
|
|
sizeY = 2;
|
|
break;
|
|
case 519:
|
|
sizeX = 1;
|
|
sizeY = this.ClimbCatTail(x, y);
|
|
y -= sizeY - 1;
|
|
break;
|
|
case 530:
|
|
sizeX = 3;
|
|
sizeY = 2;
|
|
break;
|
|
}
|
|
this.DrawMultiTileGrassInWind(unscaledPosition, zero, x, y, sizeX, sizeY);
|
|
}
|
|
}
|
|
}
|
|
|
|
private int ClimbCatTail(int originx, int originy)
|
|
{
|
|
int num = 0;
|
|
int index = originy;
|
|
while (index > 10)
|
|
{
|
|
Tile tile = Main.tile[originx, index];
|
|
if (tile.active() && tile.type == (ushort) 519)
|
|
{
|
|
if (tile.frameX >= (short) 180)
|
|
{
|
|
++num;
|
|
break;
|
|
}
|
|
--index;
|
|
++num;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
return num;
|
|
}
|
|
|
|
private void DrawMultiTileVines()
|
|
{
|
|
Vector2 unscaledPosition = Main.Camera.UnscaledPosition;
|
|
Vector2 zero = Vector2.Zero;
|
|
int index1 = 5;
|
|
int num = this._specialsCount[index1];
|
|
for (int index2 = 0; index2 < num; ++index2)
|
|
{
|
|
Point point = this._specialPositions[index1][index2];
|
|
int x = point.X;
|
|
int y = point.Y;
|
|
int sizeX = 1;
|
|
int sizeY = 1;
|
|
Tile tile = Main.tile[x, y];
|
|
if (tile != null && tile.active())
|
|
{
|
|
switch (Main.tile[x, y].type)
|
|
{
|
|
case 34:
|
|
sizeX = 3;
|
|
sizeY = 3;
|
|
break;
|
|
case 42:
|
|
case 270:
|
|
case 271:
|
|
case 572:
|
|
case 581:
|
|
sizeX = 1;
|
|
sizeY = 2;
|
|
break;
|
|
case 91:
|
|
sizeX = 1;
|
|
sizeY = 3;
|
|
break;
|
|
case 95:
|
|
case 126:
|
|
case 444:
|
|
sizeX = 2;
|
|
sizeY = 2;
|
|
break;
|
|
case 454:
|
|
sizeX = 4;
|
|
sizeY = 3;
|
|
break;
|
|
case 465:
|
|
case 591:
|
|
case 592:
|
|
sizeX = 2;
|
|
sizeY = 3;
|
|
break;
|
|
}
|
|
this.DrawMultiTileVinesInWind(unscaledPosition, zero, x, y, sizeX, sizeY);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawVines()
|
|
{
|
|
Vector2 unscaledPosition = Main.Camera.UnscaledPosition;
|
|
Vector2 zero = Vector2.Zero;
|
|
int index1 = 6;
|
|
int num = this._specialsCount[index1];
|
|
for (int index2 = 0; index2 < num; ++index2)
|
|
{
|
|
Point point = this._specialPositions[index1][index2];
|
|
int x = point.X;
|
|
int y = point.Y;
|
|
this.DrawVineStrip(unscaledPosition, zero, x, y);
|
|
}
|
|
}
|
|
|
|
private void DrawReverseVines()
|
|
{
|
|
Vector2 unscaledPosition = Main.Camera.UnscaledPosition;
|
|
Vector2 zero = Vector2.Zero;
|
|
int index1 = 9;
|
|
int num = this._specialsCount[index1];
|
|
for (int index2 = 0; index2 < num; ++index2)
|
|
{
|
|
Point point = this._specialPositions[index1][index2];
|
|
int x = point.X;
|
|
int y = point.Y;
|
|
this.DrawRisingVineStrip(unscaledPosition, zero, x, y);
|
|
}
|
|
}
|
|
|
|
private void DrawMultiTileGrassInWind(
|
|
Vector2 screenPosition,
|
|
Vector2 offSet,
|
|
int topLeftX,
|
|
int topLeftY,
|
|
int sizeX,
|
|
int sizeY)
|
|
{
|
|
float windCycle = this.GetWindCycle(topLeftX, topLeftY, this._sunflowerWindCounter);
|
|
Vector2 vector2_1 = new Vector2((float) (sizeX * 16) * 0.5f, (float) (sizeY * 16));
|
|
Vector2 vector2_2 = new Vector2((float) (topLeftX * 16 - (int) screenPosition.X) + (float) ((double) sizeX * 16.0 * 0.5), (float) (topLeftY * 16 - (int) screenPosition.Y + 16 * sizeY)) + offSet;
|
|
float num1 = 0.07f;
|
|
int type1 = (int) Main.tile[topLeftX, topLeftY].type;
|
|
Texture2D texture = (Texture2D) null;
|
|
Color color1 = Color.Transparent;
|
|
bool flag = this.InAPlaceWithWind(topLeftX, topLeftY, sizeX, sizeY);
|
|
switch (type1)
|
|
{
|
|
case 27:
|
|
texture = TextureAssets.Flames[14].Value;
|
|
color1 = Color.White;
|
|
break;
|
|
case 519:
|
|
flag = this.InAPlaceWithWind(topLeftX, topLeftY, sizeX, 1);
|
|
break;
|
|
case 521:
|
|
case 522:
|
|
case 523:
|
|
case 524:
|
|
case 525:
|
|
case 526:
|
|
case 527:
|
|
num1 = 0.0f;
|
|
flag = false;
|
|
break;
|
|
default:
|
|
num1 = 0.15f;
|
|
break;
|
|
}
|
|
for (int index1 = topLeftX; index1 < topLeftX + sizeX; ++index1)
|
|
{
|
|
for (int index2 = topLeftY; index2 < topLeftY + sizeY; ++index2)
|
|
{
|
|
Tile tile = Main.tile[index1, index2];
|
|
ushort type2 = tile.type;
|
|
if ((int) type2 == type1)
|
|
{
|
|
double num2 = (double) Math.Abs((float) (((double) (index1 - topLeftX) + 0.5) / (double) sizeX - 0.5));
|
|
short frameX = tile.frameX;
|
|
short frameY = tile.frameY;
|
|
float num3 = (float) (1.0 - (double) (index2 - topLeftY + 1) / (double) sizeY);
|
|
if ((double) num3 == 0.0)
|
|
num3 = 0.1f;
|
|
if (!flag)
|
|
num3 = 0.0f;
|
|
int tileWidth;
|
|
int tileHeight;
|
|
int tileTop;
|
|
int halfBrickHeight;
|
|
int addFrX;
|
|
int addFrY;
|
|
SpriteEffects tileSpriteEffect;
|
|
this.GetTileDrawData(index1, index2, tile, type2, ref frameX, ref frameY, out tileWidth, out tileHeight, out tileTop, out halfBrickHeight, out addFrX, out addFrY, out tileSpriteEffect, out Texture2D _, out Rectangle _, out Color _);
|
|
bool canDoDust = this._rand.Next(4) == 0;
|
|
Color color2 = Lighting.GetColor(index1, index2);
|
|
this.DrawAnimatedTile_AdjustForVisionChangers(index1, index2, tile, type2, frameX, frameY, ref color2, canDoDust);
|
|
Color lightOverride = this.DrawTiles_GetLightOverride(index2, index1, tile, type2, frameX, frameY, color2);
|
|
if (this._isActiveAndNotPaused & canDoDust)
|
|
this.DrawTiles_EmitParticles(index2, index1, tile, type2, frameX, frameY, lightOverride);
|
|
Vector2 vector2_3 = new Vector2((float) (index1 * 16 - (int) screenPosition.X), (float) (index2 * 16 - (int) screenPosition.Y + tileTop)) + offSet;
|
|
if (tile.type == (ushort) 493 && tile.frameY == (short) 0)
|
|
{
|
|
if ((double) Main.WindForVisuals >= 0.0)
|
|
tileSpriteEffect ^= SpriteEffects.FlipHorizontally;
|
|
if (!tileSpriteEffect.HasFlag((Enum) SpriteEffects.FlipHorizontally))
|
|
vector2_3.X -= 6f;
|
|
else
|
|
vector2_3.X += 6f;
|
|
}
|
|
Vector2 vector2_4 = new Vector2(windCycle * 1f, Math.Abs(windCycle) * 2f * num3);
|
|
Vector2 origin = vector2_2 - vector2_3;
|
|
Texture2D tileDrawTexture = this.GetTileDrawTexture(tile, index1, index2);
|
|
if (tileDrawTexture != null)
|
|
{
|
|
Main.spriteBatch.Draw(tileDrawTexture, vector2_2 + new Vector2(0.0f, vector2_4.Y), new Rectangle?(new Rectangle((int) frameX + addFrX, (int) frameY + addFrY, tileWidth, tileHeight - halfBrickHeight)), lightOverride, windCycle * num1 * num3, origin, 1f, tileSpriteEffect, 0.0f);
|
|
if (texture != null)
|
|
Main.spriteBatch.Draw(texture, vector2_2 + new Vector2(0.0f, vector2_4.Y), new Rectangle?(new Rectangle((int) frameX + addFrX, (int) frameY + addFrY, tileWidth, tileHeight - halfBrickHeight)), color1, windCycle * num1 * num3, origin, 1f, tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawVineStrip(Vector2 screenPosition, Vector2 offSet, int x, int startY)
|
|
{
|
|
int num1 = 0;
|
|
int num2 = 0;
|
|
Vector2 vector2 = new Vector2((float) (x * 16 + 8), (float) (startY * 16 - 2));
|
|
float num3 = MathHelper.Lerp(0.2f, 1f, Math.Abs(Main.WindForVisuals) / 1.2f);
|
|
float num4 = -0.08f * num3;
|
|
float windCycle = this.GetWindCycle(x, startY, this._vineWindCounter);
|
|
float num5 = 0.0f;
|
|
float num6 = 0.0f;
|
|
for (int index = startY; index < Main.maxTilesY - 10; ++index)
|
|
{
|
|
Tile tile = Main.tile[x, index];
|
|
if (tile != null)
|
|
{
|
|
ushort type = tile.type;
|
|
if (!tile.active() || !TileID.Sets.VineThreads[(int) type])
|
|
break;
|
|
++num1;
|
|
if (num2 >= 5)
|
|
num4 += 0.0075f * num3;
|
|
if (num2 >= 2)
|
|
num4 += 1f / 400f;
|
|
if (WallID.Sets.AllowsWind[(int) tile.wall] && (double) index < Main.worldSurface)
|
|
++num2;
|
|
float windGridPush = this.GetWindGridPush(x, index, 20, 0.01f);
|
|
if ((double) windGridPush == 0.0 && (double) num6 != 0.0)
|
|
num5 *= -0.78f;
|
|
else
|
|
num5 -= windGridPush;
|
|
num6 = windGridPush;
|
|
short frameX = tile.frameX;
|
|
short frameY = tile.frameY;
|
|
Color color = Lighting.GetColor(x, index);
|
|
int tileWidth;
|
|
int tileHeight;
|
|
int tileTop;
|
|
int halfBrickHeight;
|
|
int addFrX;
|
|
int addFrY;
|
|
SpriteEffects tileSpriteEffect;
|
|
this.GetTileDrawData(x, index, tile, type, ref frameX, ref frameY, out tileWidth, out tileHeight, out tileTop, out halfBrickHeight, out addFrX, out addFrY, out tileSpriteEffect, out Texture2D _, out Rectangle _, out Color _);
|
|
Vector2 position = new Vector2((float) -(int) screenPosition.X, (float) -(int) screenPosition.Y) + offSet + vector2;
|
|
if (tile.color() == (byte) 31)
|
|
color = Color.White;
|
|
float rotation = (float) num2 * num4 * windCycle + num5;
|
|
Texture2D tileDrawTexture = this.GetTileDrawTexture(tile, x, index);
|
|
if (tileDrawTexture == null)
|
|
break;
|
|
Main.spriteBatch.Draw(tileDrawTexture, position, new Rectangle?(new Rectangle((int) frameX + addFrX, (int) frameY + addFrY, tileWidth, tileHeight - halfBrickHeight)), color, rotation, new Vector2((float) (tileWidth / 2), (float) (halfBrickHeight - tileTop)), 1f, tileSpriteEffect, 0.0f);
|
|
vector2 += (rotation + 1.570796f).ToRotationVector2() * 16f;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void DrawRisingVineStrip(Vector2 screenPosition, Vector2 offSet, int x, int startY)
|
|
{
|
|
int num1 = 0;
|
|
int num2 = 0;
|
|
Vector2 vector2 = new Vector2((float) (x * 16 + 8), (float) (startY * 16 + 16 + 2));
|
|
float num3 = MathHelper.Lerp(0.2f, 1f, Math.Abs(Main.WindForVisuals) / 1.2f);
|
|
float num4 = -0.08f * num3;
|
|
float windCycle = this.GetWindCycle(x, startY, this._vineWindCounter);
|
|
float num5 = 0.0f;
|
|
float num6 = 0.0f;
|
|
for (int index = startY; index > 10; --index)
|
|
{
|
|
Tile tile = Main.tile[x, index];
|
|
if (tile != null)
|
|
{
|
|
ushort type = tile.type;
|
|
if (!tile.active() || !TileID.Sets.ReverseVineThreads[(int) type])
|
|
break;
|
|
++num1;
|
|
if (num2 >= 5)
|
|
num4 += 0.0075f * num3;
|
|
if (num2 >= 2)
|
|
num4 += 1f / 400f;
|
|
if (WallID.Sets.AllowsWind[(int) tile.wall] && (double) index < Main.worldSurface)
|
|
++num2;
|
|
float windGridPush = this.GetWindGridPush(x, index, 40, -0.004f);
|
|
if ((double) windGridPush == 0.0 && (double) num6 != 0.0)
|
|
num5 *= -0.78f;
|
|
else
|
|
num5 -= windGridPush;
|
|
num6 = windGridPush;
|
|
short frameX = tile.frameX;
|
|
short frameY = tile.frameY;
|
|
Color color = Lighting.GetColor(x, index);
|
|
int tileWidth;
|
|
int tileHeight;
|
|
int tileTop;
|
|
int halfBrickHeight;
|
|
int addFrX;
|
|
int addFrY;
|
|
SpriteEffects tileSpriteEffect;
|
|
this.GetTileDrawData(x, index, tile, type, ref frameX, ref frameY, out tileWidth, out tileHeight, out tileTop, out halfBrickHeight, out addFrX, out addFrY, out tileSpriteEffect, out Texture2D _, out Rectangle _, out Color _);
|
|
Vector2 position = new Vector2((float) -(int) screenPosition.X, (float) -(int) screenPosition.Y) + offSet + vector2;
|
|
float rotation = (float) num2 * -num4 * windCycle + num5;
|
|
Texture2D tileDrawTexture = this.GetTileDrawTexture(tile, x, index);
|
|
if (tileDrawTexture == null)
|
|
break;
|
|
Main.spriteBatch.Draw(tileDrawTexture, position, new Rectangle?(new Rectangle((int) frameX + addFrX, (int) frameY + addFrY, tileWidth, tileHeight - halfBrickHeight)), color, rotation, new Vector2((float) (tileWidth / 2), (float) (halfBrickHeight - tileTop + tileHeight)), 1f, tileSpriteEffect, 0.0f);
|
|
vector2 += (rotation - 1.570796f).ToRotationVector2() * 16f;
|
|
}
|
|
}
|
|
}
|
|
|
|
private float GetAverageWindGridPush(
|
|
int topLeftX,
|
|
int topLeftY,
|
|
int sizeX,
|
|
int sizeY,
|
|
int totalPushTime,
|
|
float pushForcePerFrame)
|
|
{
|
|
float num1 = 0.0f;
|
|
int num2 = 0;
|
|
for (int index1 = 0; index1 < sizeX; ++index1)
|
|
{
|
|
for (int index2 = 0; index2 < sizeY; ++index2)
|
|
{
|
|
float windGridPush = this.GetWindGridPush(topLeftX + index1, topLeftY + index2, totalPushTime, pushForcePerFrame);
|
|
if ((double) windGridPush != 0.0)
|
|
{
|
|
num1 += windGridPush;
|
|
++num2;
|
|
}
|
|
}
|
|
}
|
|
return num2 == 0 ? 0.0f : num1 / (float) num2;
|
|
}
|
|
|
|
private float GetHighestWindGridPushComplex(
|
|
int topLeftX,
|
|
int topLeftY,
|
|
int sizeX,
|
|
int sizeY,
|
|
int totalPushTime,
|
|
float pushForcePerFrame,
|
|
int loops,
|
|
bool swapLoopDir)
|
|
{
|
|
float num1 = 0.0f;
|
|
int num2 = int.MaxValue;
|
|
for (int index1 = 0; index1 < 1; ++index1)
|
|
{
|
|
for (int index2 = 0; index2 < sizeY; ++index2)
|
|
{
|
|
int windTimeLeft;
|
|
this._windGrid.GetWindTime(topLeftX + index1 + sizeX / 2, topLeftY + index2, totalPushTime, out windTimeLeft, out int _);
|
|
float windGridPushComplex = this.GetWindGridPushComplex(topLeftX + index1, topLeftY + index2, totalPushTime, pushForcePerFrame, loops, swapLoopDir);
|
|
if (windTimeLeft < num2 && windTimeLeft != 0)
|
|
{
|
|
num1 = windGridPushComplex;
|
|
num2 = windTimeLeft;
|
|
}
|
|
}
|
|
}
|
|
return num1;
|
|
}
|
|
|
|
private void DrawMultiTileVinesInWind(
|
|
Vector2 screenPosition,
|
|
Vector2 offSet,
|
|
int topLeftX,
|
|
int topLeftY,
|
|
int sizeX,
|
|
int sizeY)
|
|
{
|
|
float windCycle = this.GetWindCycle(topLeftX, topLeftY, this._sunflowerWindCounter);
|
|
float num1 = windCycle;
|
|
int totalPushTime = 60;
|
|
float pushForcePerFrame = 1.26f;
|
|
float windGridPushComplex = this.GetHighestWindGridPushComplex(topLeftX, topLeftY, sizeX, sizeY, totalPushTime, pushForcePerFrame, 3, true);
|
|
float num2 = windCycle + windGridPushComplex;
|
|
Vector2 vector2_1 = new Vector2((float) (sizeX * 16) * 0.5f, 0.0f);
|
|
Vector2 vector2_2 = new Vector2((float) (topLeftX * 16 - (int) screenPosition.X) + (float) ((double) sizeX * 16.0 * 0.5), (float) (topLeftY * 16 - (int) screenPosition.Y)) + offSet;
|
|
Tile tile1 = Main.tile[topLeftX, topLeftY];
|
|
int type1 = (int) tile1.type;
|
|
Vector2 vector2_3 = new Vector2(0.0f, -2f);
|
|
Vector2 vector2_4 = vector2_2 + vector2_3;
|
|
Texture2D texture = (Texture2D) null;
|
|
Color color = Color.Transparent;
|
|
float? nullable = new float?();
|
|
float num3 = 1f;
|
|
float num4 = -4f;
|
|
bool flag = false;
|
|
float num5 = 0.15f;
|
|
switch (type1)
|
|
{
|
|
case 34:
|
|
case 126:
|
|
nullable = new float?(1f);
|
|
num4 = 0.0f;
|
|
switch ((int) tile1.frameY / 54 + (int) tile1.frameX / 108 * 37)
|
|
{
|
|
case 9:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
flag = true;
|
|
num5 *= 0.3f;
|
|
break;
|
|
case 11:
|
|
num5 *= 0.5f;
|
|
break;
|
|
case 12:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
break;
|
|
case 18:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
break;
|
|
case 21:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
break;
|
|
case 23:
|
|
nullable = new float?(0.0f);
|
|
break;
|
|
case 25:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
flag = true;
|
|
break;
|
|
case 32:
|
|
num5 *= 0.5f;
|
|
break;
|
|
case 33:
|
|
num5 *= 0.5f;
|
|
break;
|
|
case 35:
|
|
nullable = new float?(0.0f);
|
|
break;
|
|
case 36:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
flag = true;
|
|
break;
|
|
case 37:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
flag = true;
|
|
num5 *= 0.5f;
|
|
break;
|
|
case 39:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
flag = true;
|
|
break;
|
|
case 40:
|
|
case 41:
|
|
case 42:
|
|
case 43:
|
|
nullable = new float?();
|
|
num4 = -2f;
|
|
flag = true;
|
|
num5 *= 0.5f;
|
|
break;
|
|
case 44:
|
|
nullable = new float?();
|
|
num4 = -3f;
|
|
break;
|
|
}
|
|
break;
|
|
case 42:
|
|
nullable = new float?(1f);
|
|
num4 = 0.0f;
|
|
switch ((int) tile1.frameY / 36)
|
|
{
|
|
case 0:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
break;
|
|
case 9:
|
|
nullable = new float?(0.0f);
|
|
break;
|
|
case 12:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
break;
|
|
case 14:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
break;
|
|
case 28:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
break;
|
|
case 30:
|
|
nullable = new float?(0.0f);
|
|
break;
|
|
case 32:
|
|
nullable = new float?(0.0f);
|
|
break;
|
|
case 33:
|
|
nullable = new float?(0.0f);
|
|
break;
|
|
case 34:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
break;
|
|
case 35:
|
|
nullable = new float?(0.0f);
|
|
break;
|
|
case 38:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
break;
|
|
case 39:
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
flag = true;
|
|
break;
|
|
case 40:
|
|
case 41:
|
|
case 42:
|
|
case 43:
|
|
nullable = new float?(0.0f);
|
|
nullable = new float?();
|
|
num4 = -1f;
|
|
flag = true;
|
|
break;
|
|
}
|
|
break;
|
|
case 95:
|
|
case 270:
|
|
case 271:
|
|
case 444:
|
|
case 454:
|
|
case 572:
|
|
case 581:
|
|
nullable = new float?(1f);
|
|
num4 = 0.0f;
|
|
break;
|
|
case 591:
|
|
num3 = 0.5f;
|
|
num4 = -2f;
|
|
break;
|
|
case 592:
|
|
num3 = 0.5f;
|
|
num4 = -2f;
|
|
texture = TextureAssets.GlowMask[294].Value;
|
|
color = new Color((int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue, 0);
|
|
break;
|
|
}
|
|
if (flag)
|
|
vector2_4 += new Vector2(0.0f, 16f);
|
|
float num6 = num5 * -1f;
|
|
if (!this.InAPlaceWithWind(topLeftX, topLeftY, sizeX, sizeY))
|
|
num2 -= num1;
|
|
ulong num7 = 0;
|
|
for (int index1 = topLeftX; index1 < topLeftX + sizeX; ++index1)
|
|
{
|
|
for (int index2 = topLeftY; index2 < topLeftY + sizeY; ++index2)
|
|
{
|
|
Tile tile2 = Main.tile[index1, index2];
|
|
ushort type2 = tile2.type;
|
|
if ((int) type2 == type1)
|
|
{
|
|
double num8 = (double) Math.Abs((float) (((double) (index1 - topLeftX) + 0.5) / (double) sizeX - 0.5));
|
|
short frameX = tile2.frameX;
|
|
short frameY = tile2.frameY;
|
|
float num9 = (float) (index2 - topLeftY + 1) / (float) sizeY;
|
|
if ((double) num9 == 0.0)
|
|
num9 = 0.1f;
|
|
if (nullable.HasValue)
|
|
num9 = nullable.Value;
|
|
if (flag && index2 == topLeftY)
|
|
num9 = 0.0f;
|
|
int tileWidth;
|
|
int tileHeight;
|
|
int tileTop;
|
|
int halfBrickHeight;
|
|
int addFrX;
|
|
int addFrY;
|
|
SpriteEffects tileSpriteEffect;
|
|
this.GetTileDrawData(index1, index2, tile2, type2, ref frameX, ref frameY, out tileWidth, out tileHeight, out tileTop, out halfBrickHeight, out addFrX, out addFrY, out tileSpriteEffect, out Texture2D _, out Rectangle _, out Color _);
|
|
bool canDoDust = this._rand.Next(4) == 0;
|
|
Color tileLight = Lighting.GetColor(index1, index2);
|
|
this.DrawAnimatedTile_AdjustForVisionChangers(index1, index2, tile2, type2, frameX, frameY, ref tileLight, canDoDust);
|
|
tileLight = this.DrawTiles_GetLightOverride(index2, index1, tile2, type2, frameX, frameY, tileLight);
|
|
if (this._isActiveAndNotPaused & canDoDust)
|
|
this.DrawTiles_EmitParticles(index2, index1, tile2, type2, frameX, frameY, tileLight);
|
|
Vector2 vector2_5 = new Vector2((float) (index1 * 16 - (int) screenPosition.X), (float) (index2 * 16 - (int) screenPosition.Y + tileTop)) + offSet + vector2_3;
|
|
Vector2 vector2_6 = new Vector2(num2 * num3, Math.Abs(num2) * num4 * num9);
|
|
Vector2 origin = vector2_4 - vector2_5;
|
|
Texture2D tileDrawTexture = this.GetTileDrawTexture(tile2, index1, index2);
|
|
if (tileDrawTexture != null)
|
|
{
|
|
Vector2 position = vector2_4 + new Vector2(0.0f, vector2_6.Y);
|
|
Rectangle rectangle = new Rectangle((int) frameX + addFrX, (int) frameY + addFrY, tileWidth, tileHeight - halfBrickHeight);
|
|
float rotation = num2 * num6 * num9;
|
|
Main.spriteBatch.Draw(tileDrawTexture, position, new Rectangle?(rectangle), tileLight, rotation, origin, 1f, tileSpriteEffect, 0.0f);
|
|
if (texture != null)
|
|
Main.spriteBatch.Draw(texture, position, new Rectangle?(rectangle), color, rotation, origin, 1f, tileSpriteEffect, 0.0f);
|
|
TileDrawing.TileFlameData tileFlameData = this.GetTileFlameData(index1, index2, (int) type2, (int) frameY);
|
|
if (num7 == 0UL)
|
|
num7 = tileFlameData.flameSeed;
|
|
tileFlameData.flameSeed = num7;
|
|
for (int index3 = 0; index3 < tileFlameData.flameCount; ++index3)
|
|
{
|
|
float x = (float) Utils.RandomInt(ref tileFlameData.flameSeed, tileFlameData.flameRangeXMin, tileFlameData.flameRangeXMax) * tileFlameData.flameRangeMultX;
|
|
float y = (float) Utils.RandomInt(ref tileFlameData.flameSeed, tileFlameData.flameRangeYMin, tileFlameData.flameRangeYMax) * tileFlameData.flameRangeMultY;
|
|
Main.spriteBatch.Draw(tileFlameData.flameTexture, position + new Vector2(x, y), new Rectangle?(rectangle), tileFlameData.flameColor, rotation, origin, 1f, tileSpriteEffect, 0.0f);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void EmitAlchemyHerbParticles(int j, int i, int style)
|
|
{
|
|
if (style == 0 && this._rand.Next(100) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16 - 4)), 16, 16, 19, Alpha: 160, Scale: 0.1f);
|
|
this._dust[index].velocity.X /= 2f;
|
|
this._dust[index].velocity.Y /= 2f;
|
|
this._dust[index].noGravity = true;
|
|
this._dust[index].fadeIn = 1f;
|
|
}
|
|
if (style == 1 && this._rand.Next(100) == 0)
|
|
Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 41, Alpha: 250, Scale: 0.8f);
|
|
if (style == 3)
|
|
{
|
|
if (this._rand.Next(200) == 0)
|
|
this._dust[Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 14, Alpha: 100, Scale: 0.2f)].fadeIn = 1.2f;
|
|
if (this._rand.Next(75) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 27, Alpha: 100);
|
|
this._dust[index].velocity.X /= 2f;
|
|
this._dust[index].velocity.Y /= 2f;
|
|
}
|
|
}
|
|
if (style == 4 && this._rand.Next(150) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 8, 16);
|
|
this._dust[index].velocity.X /= 3f;
|
|
this._dust[index].velocity.Y /= 3f;
|
|
this._dust[index].velocity.Y -= 0.7f;
|
|
this._dust[index].alpha = 50;
|
|
this._dust[index].scale *= 0.1f;
|
|
this._dust[index].fadeIn = 0.9f;
|
|
this._dust[index].noGravity = true;
|
|
}
|
|
if (style == 5 && this._rand.Next(40) == 0)
|
|
{
|
|
int index = Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16 - 6)), 16, 16, 6, Scale: 1.5f);
|
|
this._dust[index].velocity.Y -= 2f;
|
|
this._dust[index].noGravity = true;
|
|
}
|
|
if (style != 6 || this._rand.Next(30) != 0)
|
|
return;
|
|
Color newColor = new Color(50, (int) byte.MaxValue, (int) byte.MaxValue, (int) byte.MaxValue);
|
|
this._dust[Dust.NewDust(new Vector2((float) (i * 16), (float) (j * 16)), 16, 16, 43, Alpha: 254, newColor: newColor, Scale: 0.5f)].velocity *= 0.0f;
|
|
}
|
|
|
|
private bool IsAlchemyPlantHarvestable(int style) => style == 0 && Main.dayTime || style == 1 && !Main.dayTime || style == 3 && !Main.dayTime && (Main.bloodMoon || Main.moonPhase == 0) || style == 4 && (Main.raining || (double) Main.cloudAlpha > 0.0) || style == 5 && !Main.raining && Main.time > 40500.0;
|
|
|
|
private enum TileCounterType
|
|
{
|
|
Tree,
|
|
DisplayDoll,
|
|
HatRack,
|
|
WindyGrass,
|
|
MultiTileGrass,
|
|
MultiTileVine,
|
|
Vine,
|
|
BiomeGrass,
|
|
VoidLens,
|
|
ReverseVine,
|
|
TeleportationPylon,
|
|
MasterTrophy,
|
|
Count,
|
|
}
|
|
|
|
private struct TileFlameData
|
|
{
|
|
public Texture2D flameTexture;
|
|
public ulong flameSeed;
|
|
public int flameCount;
|
|
public Color flameColor;
|
|
public int flameRangeXMin;
|
|
public int flameRangeXMax;
|
|
public int flameRangeYMin;
|
|
public int flameRangeYMax;
|
|
public float flameRangeMultX;
|
|
public float flameRangeMultY;
|
|
}
|
|
}
|
|
}
|