1480 lines
53 KiB
C#
1480 lines
53 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Terraria.Minecart
|
|
// 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 System;
|
|
using Terraria.GameContent;
|
|
|
|
namespace Terraria
|
|
{
|
|
public static class Minecart
|
|
{
|
|
private const int TotalFrames = 36;
|
|
public const int LeftDownDecoration = 36;
|
|
public const int RightDownDecoration = 37;
|
|
public const int BouncyBumperDecoration = 38;
|
|
public const int RegularBumperDecoration = 39;
|
|
public const int Flag_OnTrack = 0;
|
|
public const int Flag_BouncyBumper = 1;
|
|
public const int Flag_UsedRamp = 2;
|
|
public const int Flag_HitSwitch = 3;
|
|
public const int Flag_BoostLeft = 4;
|
|
public const int Flag_BoostRight = 5;
|
|
private const int NoConnection = -1;
|
|
private const int TopConnection = 0;
|
|
private const int MiddleConnection = 1;
|
|
private const int BottomConnection = 2;
|
|
private const int BumperEnd = -1;
|
|
private const int BouncyEnd = -2;
|
|
private const int RampEnd = -3;
|
|
private const int OpenEnd = -4;
|
|
public const float BoosterSpeed = 4f;
|
|
private const int Type_Normal = 0;
|
|
private const int Type_Pressure = 1;
|
|
private const int Type_Booster = 2;
|
|
private static Vector2 _trackMagnetOffset = new Vector2(25f, 26f);
|
|
private const float MinecartTextureWidth = 50f;
|
|
private static int[] _leftSideConnection;
|
|
private static int[] _rightSideConnection;
|
|
private static int[] _trackType;
|
|
private static bool[] _boostLeft;
|
|
private static Vector2[] _texturePosition;
|
|
private static short _firstPressureFrame;
|
|
private static short _firstLeftBoostFrame;
|
|
private static short _firstRightBoostFrame;
|
|
private static int[][] _trackSwitchOptions;
|
|
private static int[][] _tileHeight;
|
|
|
|
public static void Initialize()
|
|
{
|
|
if ((double) TextureAssets.MinecartMount.Width() != 50.0)
|
|
throw new Exception("Be sure to update Minecart.textureWidth to match the actual texture size of " + (object) 50f + ".");
|
|
Minecart._rightSideConnection = new int[36];
|
|
Minecart._leftSideConnection = new int[36];
|
|
Minecart._trackType = new int[36];
|
|
Minecart._boostLeft = new bool[36];
|
|
Minecart._texturePosition = new Vector2[40];
|
|
Minecart._tileHeight = new int[36][];
|
|
for (int index1 = 0; index1 < 36; ++index1)
|
|
{
|
|
int[] numArray = new int[8];
|
|
for (int index2 = 0; index2 < numArray.Length; ++index2)
|
|
numArray[index2] = 5;
|
|
Minecart._tileHeight[index1] = numArray;
|
|
}
|
|
int index3 = 0;
|
|
Minecart._leftSideConnection[index3] = -1;
|
|
Minecart._rightSideConnection[index3] = -1;
|
|
Minecart._tileHeight[index3][0] = -4;
|
|
Minecart._tileHeight[index3][7] = -4;
|
|
Minecart._texturePosition[index3] = new Vector2(0.0f, 0.0f);
|
|
int index4 = index3 + 1;
|
|
Minecart._leftSideConnection[index4] = 1;
|
|
Minecart._rightSideConnection[index4] = 1;
|
|
Minecart._texturePosition[index4] = new Vector2(1f, 0.0f);
|
|
int index5 = index4 + 1;
|
|
Minecart._leftSideConnection[index5] = -1;
|
|
Minecart._rightSideConnection[index5] = 1;
|
|
for (int index6 = 0; index6 < 4; ++index6)
|
|
Minecart._tileHeight[index5][index6] = -1;
|
|
Minecart._texturePosition[index5] = new Vector2(2f, 1f);
|
|
int index7 = index5 + 1;
|
|
Minecart._leftSideConnection[index7] = 1;
|
|
Minecart._rightSideConnection[index7] = -1;
|
|
for (int index8 = 4; index8 < 8; ++index8)
|
|
Minecart._tileHeight[index7][index8] = -1;
|
|
Minecart._texturePosition[index7] = new Vector2(3f, 1f);
|
|
int index9 = index7 + 1;
|
|
Minecart._leftSideConnection[index9] = 2;
|
|
Minecart._rightSideConnection[index9] = 1;
|
|
Minecart._tileHeight[index9][0] = 1;
|
|
Minecart._tileHeight[index9][1] = 2;
|
|
Minecart._tileHeight[index9][2] = 3;
|
|
Minecart._tileHeight[index9][3] = 3;
|
|
Minecart._tileHeight[index9][4] = 4;
|
|
Minecart._tileHeight[index9][5] = 4;
|
|
Minecart._texturePosition[index9] = new Vector2(0.0f, 2f);
|
|
int index10 = index9 + 1;
|
|
Minecart._leftSideConnection[index10] = 1;
|
|
Minecart._rightSideConnection[index10] = 2;
|
|
Minecart._tileHeight[index10][2] = 4;
|
|
Minecart._tileHeight[index10][3] = 4;
|
|
Minecart._tileHeight[index10][4] = 3;
|
|
Minecart._tileHeight[index10][5] = 3;
|
|
Minecart._tileHeight[index10][6] = 2;
|
|
Minecart._tileHeight[index10][7] = 1;
|
|
Minecart._texturePosition[index10] = new Vector2(1f, 2f);
|
|
int index11 = index10 + 1;
|
|
Minecart._leftSideConnection[index11] = 1;
|
|
Minecart._rightSideConnection[index11] = 0;
|
|
Minecart._tileHeight[index11][4] = 6;
|
|
Minecart._tileHeight[index11][5] = 6;
|
|
Minecart._tileHeight[index11][6] = 7;
|
|
Minecart._tileHeight[index11][7] = 8;
|
|
Minecart._texturePosition[index11] = new Vector2(0.0f, 1f);
|
|
int index12 = index11 + 1;
|
|
Minecart._leftSideConnection[index12] = 0;
|
|
Minecart._rightSideConnection[index12] = 1;
|
|
Minecart._tileHeight[index12][0] = 8;
|
|
Minecart._tileHeight[index12][1] = 7;
|
|
Minecart._tileHeight[index12][2] = 6;
|
|
Minecart._tileHeight[index12][3] = 6;
|
|
Minecart._texturePosition[index12] = new Vector2(1f, 1f);
|
|
int index13 = index12 + 1;
|
|
Minecart._leftSideConnection[index13] = 0;
|
|
Minecart._rightSideConnection[index13] = 2;
|
|
for (int index14 = 0; index14 < 8; ++index14)
|
|
Minecart._tileHeight[index13][index14] = 8 - index14;
|
|
Minecart._texturePosition[index13] = new Vector2(0.0f, 3f);
|
|
int index15 = index13 + 1;
|
|
Minecart._leftSideConnection[index15] = 2;
|
|
Minecart._rightSideConnection[index15] = 0;
|
|
for (int index16 = 0; index16 < 8; ++index16)
|
|
Minecart._tileHeight[index15][index16] = index16 + 1;
|
|
Minecart._texturePosition[index15] = new Vector2(1f, 3f);
|
|
int index17 = index15 + 1;
|
|
Minecart._leftSideConnection[index17] = 2;
|
|
Minecart._rightSideConnection[index17] = -1;
|
|
Minecart._tileHeight[index17][0] = 1;
|
|
Minecart._tileHeight[index17][1] = 2;
|
|
for (int index18 = 2; index18 < 8; ++index18)
|
|
Minecart._tileHeight[index17][index18] = -1;
|
|
Minecart._texturePosition[index17] = new Vector2(4f, 1f);
|
|
int index19 = index17 + 1;
|
|
Minecart._leftSideConnection[index19] = -1;
|
|
Minecart._rightSideConnection[index19] = 2;
|
|
Minecart._tileHeight[index19][6] = 2;
|
|
Minecart._tileHeight[index19][7] = 1;
|
|
for (int index20 = 0; index20 < 6; ++index20)
|
|
Minecart._tileHeight[index19][index20] = -1;
|
|
Minecart._texturePosition[index19] = new Vector2(5f, 1f);
|
|
int index21 = index19 + 1;
|
|
Minecart._leftSideConnection[index21] = 0;
|
|
Minecart._rightSideConnection[index21] = -1;
|
|
Minecart._tileHeight[index21][0] = 8;
|
|
Minecart._tileHeight[index21][1] = 7;
|
|
Minecart._tileHeight[index21][2] = 6;
|
|
for (int index22 = 3; index22 < 8; ++index22)
|
|
Minecart._tileHeight[index21][index22] = -1;
|
|
Minecart._texturePosition[index21] = new Vector2(6f, 1f);
|
|
int index23 = index21 + 1;
|
|
Minecart._leftSideConnection[index23] = -1;
|
|
Minecart._rightSideConnection[index23] = 0;
|
|
Minecart._tileHeight[index23][5] = 6;
|
|
Minecart._tileHeight[index23][6] = 7;
|
|
Minecart._tileHeight[index23][7] = 8;
|
|
for (int index24 = 0; index24 < 5; ++index24)
|
|
Minecart._tileHeight[index23][index24] = -1;
|
|
Minecart._texturePosition[index23] = new Vector2(7f, 1f);
|
|
int index25 = index23 + 1;
|
|
Minecart._leftSideConnection[index25] = -1;
|
|
Minecart._rightSideConnection[index25] = 1;
|
|
Minecart._tileHeight[index25][0] = -4;
|
|
Minecart._texturePosition[index25] = new Vector2(2f, 0.0f);
|
|
int index26 = index25 + 1;
|
|
Minecart._leftSideConnection[index26] = 1;
|
|
Minecart._rightSideConnection[index26] = -1;
|
|
Minecart._tileHeight[index26][7] = -4;
|
|
Minecart._texturePosition[index26] = new Vector2(3f, 0.0f);
|
|
int index27 = index26 + 1;
|
|
Minecart._leftSideConnection[index27] = 2;
|
|
Minecart._rightSideConnection[index27] = -1;
|
|
for (int index28 = 0; index28 < 6; ++index28)
|
|
Minecart._tileHeight[index27][index28] = index28 + 1;
|
|
Minecart._tileHeight[index27][6] = -3;
|
|
Minecart._tileHeight[index27][7] = -3;
|
|
Minecart._texturePosition[index27] = new Vector2(4f, 0.0f);
|
|
int index29 = index27 + 1;
|
|
Minecart._leftSideConnection[index29] = -1;
|
|
Minecart._rightSideConnection[index29] = 2;
|
|
Minecart._tileHeight[index29][0] = -3;
|
|
Minecart._tileHeight[index29][1] = -3;
|
|
for (int index30 = 2; index30 < 8; ++index30)
|
|
Minecart._tileHeight[index29][index30] = 8 - index30;
|
|
Minecart._texturePosition[index29] = new Vector2(5f, 0.0f);
|
|
int index31 = index29 + 1;
|
|
Minecart._leftSideConnection[index31] = 0;
|
|
Minecart._rightSideConnection[index31] = -1;
|
|
for (int index32 = 0; index32 < 6; ++index32)
|
|
Minecart._tileHeight[index31][index32] = 8 - index32;
|
|
Minecart._tileHeight[index31][6] = -3;
|
|
Minecart._tileHeight[index31][7] = -3;
|
|
Minecart._texturePosition[index31] = new Vector2(6f, 0.0f);
|
|
int index33 = index31 + 1;
|
|
Minecart._leftSideConnection[index33] = -1;
|
|
Minecart._rightSideConnection[index33] = 0;
|
|
Minecart._tileHeight[index33][0] = -3;
|
|
Minecart._tileHeight[index33][1] = -3;
|
|
for (int index34 = 2; index34 < 8; ++index34)
|
|
Minecart._tileHeight[index33][index34] = index34 + 1;
|
|
Minecart._texturePosition[index33] = new Vector2(7f, 0.0f);
|
|
int index35 = index33 + 1;
|
|
Minecart._leftSideConnection[index35] = -1;
|
|
Minecart._rightSideConnection[index35] = -1;
|
|
Minecart._tileHeight[index35][0] = -4;
|
|
Minecart._tileHeight[index35][7] = -4;
|
|
Minecart._trackType[index35] = 1;
|
|
Minecart._texturePosition[index35] = new Vector2(0.0f, 4f);
|
|
int index36 = index35 + 1;
|
|
Minecart._leftSideConnection[index36] = 1;
|
|
Minecart._rightSideConnection[index36] = 1;
|
|
Minecart._trackType[index36] = 1;
|
|
Minecart._texturePosition[index36] = new Vector2(1f, 4f);
|
|
int index37 = index36 + 1;
|
|
Minecart._leftSideConnection[index37] = -1;
|
|
Minecart._rightSideConnection[index37] = 1;
|
|
Minecart._tileHeight[index37][0] = -4;
|
|
Minecart._trackType[index37] = 1;
|
|
Minecart._texturePosition[index37] = new Vector2(0.0f, 5f);
|
|
int index38 = index37 + 1;
|
|
Minecart._leftSideConnection[index38] = 1;
|
|
Minecart._rightSideConnection[index38] = -1;
|
|
Minecart._tileHeight[index38][7] = -4;
|
|
Minecart._trackType[index38] = 1;
|
|
Minecart._texturePosition[index38] = new Vector2(1f, 5f);
|
|
int index39 = index38 + 1;
|
|
Minecart._leftSideConnection[index39] = -1;
|
|
Minecart._rightSideConnection[index39] = 1;
|
|
for (int index40 = 0; index40 < 6; ++index40)
|
|
Minecart._tileHeight[index39][index40] = -2;
|
|
Minecart._texturePosition[index39] = new Vector2(2f, 2f);
|
|
int index41 = index39 + 1;
|
|
Minecart._leftSideConnection[index41] = 1;
|
|
Minecart._rightSideConnection[index41] = -1;
|
|
for (int index42 = 2; index42 < 8; ++index42)
|
|
Minecart._tileHeight[index41][index42] = -2;
|
|
Minecart._texturePosition[index41] = new Vector2(3f, 2f);
|
|
int index43 = index41 + 1;
|
|
Minecart._leftSideConnection[index43] = 2;
|
|
Minecart._rightSideConnection[index43] = -1;
|
|
Minecart._tileHeight[index43][0] = 1;
|
|
Minecart._tileHeight[index43][1] = 2;
|
|
for (int index44 = 2; index44 < 8; ++index44)
|
|
Minecart._tileHeight[index43][index44] = -2;
|
|
Minecart._texturePosition[index43] = new Vector2(4f, 2f);
|
|
int index45 = index43 + 1;
|
|
Minecart._leftSideConnection[index45] = -1;
|
|
Minecart._rightSideConnection[index45] = 2;
|
|
Minecart._tileHeight[index45][6] = 2;
|
|
Minecart._tileHeight[index45][7] = 1;
|
|
for (int index46 = 0; index46 < 6; ++index46)
|
|
Minecart._tileHeight[index45][index46] = -2;
|
|
Minecart._texturePosition[index45] = new Vector2(5f, 2f);
|
|
int index47 = index45 + 1;
|
|
Minecart._leftSideConnection[index47] = 0;
|
|
Minecart._rightSideConnection[index47] = -1;
|
|
Minecart._tileHeight[index47][0] = 8;
|
|
Minecart._tileHeight[index47][1] = 7;
|
|
Minecart._tileHeight[index47][2] = 6;
|
|
for (int index48 = 3; index48 < 8; ++index48)
|
|
Minecart._tileHeight[index47][index48] = -2;
|
|
Minecart._texturePosition[index47] = new Vector2(6f, 2f);
|
|
int index49 = index47 + 1;
|
|
Minecart._leftSideConnection[index49] = -1;
|
|
Minecart._rightSideConnection[index49] = 0;
|
|
Minecart._tileHeight[index49][5] = 6;
|
|
Minecart._tileHeight[index49][6] = 7;
|
|
Minecart._tileHeight[index49][7] = 8;
|
|
for (int index50 = 0; index50 < 5; ++index50)
|
|
Minecart._tileHeight[index49][index50] = -2;
|
|
Minecart._texturePosition[index49] = new Vector2(7f, 2f);
|
|
int index51 = index49 + 1;
|
|
Minecart._leftSideConnection[index51] = 1;
|
|
Minecart._rightSideConnection[index51] = 1;
|
|
Minecart._trackType[index51] = 2;
|
|
Minecart._boostLeft[index51] = false;
|
|
Minecart._texturePosition[index51] = new Vector2(2f, 3f);
|
|
int index52 = index51 + 1;
|
|
Minecart._leftSideConnection[index52] = 1;
|
|
Minecart._rightSideConnection[index52] = 1;
|
|
Minecart._trackType[index52] = 2;
|
|
Minecart._boostLeft[index52] = true;
|
|
Minecart._texturePosition[index52] = new Vector2(3f, 3f);
|
|
int index53 = index52 + 1;
|
|
Minecart._leftSideConnection[index53] = 0;
|
|
Minecart._rightSideConnection[index53] = 2;
|
|
for (int index54 = 0; index54 < 8; ++index54)
|
|
Minecart._tileHeight[index53][index54] = 8 - index54;
|
|
Minecart._trackType[index53] = 2;
|
|
Minecart._boostLeft[index53] = false;
|
|
Minecart._texturePosition[index53] = new Vector2(4f, 3f);
|
|
int index55 = index53 + 1;
|
|
Minecart._leftSideConnection[index55] = 2;
|
|
Minecart._rightSideConnection[index55] = 0;
|
|
for (int index56 = 0; index56 < 8; ++index56)
|
|
Minecart._tileHeight[index55][index56] = index56 + 1;
|
|
Minecart._trackType[index55] = 2;
|
|
Minecart._boostLeft[index55] = true;
|
|
Minecart._texturePosition[index55] = new Vector2(5f, 3f);
|
|
int index57 = index55 + 1;
|
|
Minecart._leftSideConnection[index57] = 0;
|
|
Minecart._rightSideConnection[index57] = 2;
|
|
for (int index58 = 0; index58 < 8; ++index58)
|
|
Minecart._tileHeight[index57][index58] = 8 - index58;
|
|
Minecart._trackType[index57] = 2;
|
|
Minecart._boostLeft[index57] = true;
|
|
Minecart._texturePosition[index57] = new Vector2(6f, 3f);
|
|
int index59 = index57 + 1;
|
|
Minecart._leftSideConnection[index59] = 2;
|
|
Minecart._rightSideConnection[index59] = 0;
|
|
for (int index60 = 0; index60 < 8; ++index60)
|
|
Minecart._tileHeight[index59][index60] = index60 + 1;
|
|
Minecart._trackType[index59] = 2;
|
|
Minecart._boostLeft[index59] = false;
|
|
Minecart._texturePosition[index59] = new Vector2(7f, 3f);
|
|
int num1 = index59 + 1;
|
|
Minecart._texturePosition[36] = new Vector2(0.0f, 6f);
|
|
Minecart._texturePosition[37] = new Vector2(1f, 6f);
|
|
Minecart._texturePosition[39] = new Vector2(0.0f, 7f);
|
|
Minecart._texturePosition[38] = new Vector2(1f, 7f);
|
|
for (int index61 = 0; index61 < Minecart._texturePosition.Length; ++index61)
|
|
Minecart._texturePosition[index61] = Minecart._texturePosition[index61] * 18f;
|
|
for (int index62 = 0; index62 < Minecart._tileHeight.Length; ++index62)
|
|
{
|
|
int[] numArray = Minecart._tileHeight[index62];
|
|
for (int index63 = 0; index63 < numArray.Length; ++index63)
|
|
{
|
|
if (numArray[index63] >= 0)
|
|
numArray[index63] = (8 - numArray[index63]) * 2;
|
|
}
|
|
}
|
|
int[] numArray1 = new int[36];
|
|
Minecart._trackSwitchOptions = new int[64][];
|
|
for (int index64 = 0; index64 < 64; ++index64)
|
|
{
|
|
int num2 = 0;
|
|
for (int index65 = 1; index65 < 256; index65 <<= 1)
|
|
{
|
|
if ((index64 & index65) == index65)
|
|
++num2;
|
|
}
|
|
int length = 0;
|
|
for (int index66 = 0; index66 < 36; ++index66)
|
|
{
|
|
numArray1[index66] = -1;
|
|
int num3 = 0;
|
|
switch (Minecart._leftSideConnection[index66])
|
|
{
|
|
case 0:
|
|
num3 |= 1;
|
|
break;
|
|
case 1:
|
|
num3 |= 2;
|
|
break;
|
|
case 2:
|
|
num3 |= 4;
|
|
break;
|
|
}
|
|
switch (Minecart._rightSideConnection[index66])
|
|
{
|
|
case 0:
|
|
num3 |= 8;
|
|
break;
|
|
case 1:
|
|
num3 |= 16;
|
|
break;
|
|
case 2:
|
|
num3 |= 32;
|
|
break;
|
|
}
|
|
if (num2 < 2)
|
|
{
|
|
if (index64 != num3)
|
|
continue;
|
|
}
|
|
else if (num3 == 0 || (index64 & num3) != num3)
|
|
continue;
|
|
numArray1[index66] = index66;
|
|
++length;
|
|
}
|
|
if (length != 0)
|
|
{
|
|
int[] numArray2 = new int[length];
|
|
int index67 = 0;
|
|
for (int index68 = 0; index68 < 36; ++index68)
|
|
{
|
|
if (numArray1[index68] != -1)
|
|
{
|
|
numArray2[index67] = numArray1[index68];
|
|
++index67;
|
|
}
|
|
}
|
|
Minecart._trackSwitchOptions[index64] = numArray2;
|
|
}
|
|
}
|
|
Minecart._firstPressureFrame = (short) -1;
|
|
Minecart._firstLeftBoostFrame = (short) -1;
|
|
Minecart._firstRightBoostFrame = (short) -1;
|
|
for (int index69 = 0; index69 < Minecart._trackType.Length; ++index69)
|
|
{
|
|
switch (Minecart._trackType[index69])
|
|
{
|
|
case 1:
|
|
if (Minecart._firstPressureFrame == (short) -1)
|
|
{
|
|
Minecart._firstPressureFrame = (short) index69;
|
|
break;
|
|
}
|
|
break;
|
|
case 2:
|
|
if (Minecart._boostLeft[index69])
|
|
{
|
|
if (Minecart._firstLeftBoostFrame == (short) -1)
|
|
{
|
|
Minecart._firstLeftBoostFrame = (short) index69;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (Minecart._firstRightBoostFrame == (short) -1)
|
|
{
|
|
Minecart._firstRightBoostFrame = (short) index69;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static bool IsPressurePlate(Tile tile) => tile.active() && tile.type == (ushort) 314 && (tile.frameX == (short) 20 || tile.frameX == (short) 21);
|
|
|
|
public static BitsByte TrackCollision(
|
|
ref Vector2 Position,
|
|
ref Vector2 Velocity,
|
|
ref Vector2 lastBoost,
|
|
int Width,
|
|
int Height,
|
|
bool followDown,
|
|
bool followUp,
|
|
int fallStart,
|
|
bool trackOnly,
|
|
Mount.MountDelegatesData delegatesData)
|
|
{
|
|
if (followDown & followUp)
|
|
{
|
|
followDown = false;
|
|
followUp = false;
|
|
}
|
|
Vector2 vector2_1 = new Vector2((float) (Width / 2) - 25f, (float) (Height / 2));
|
|
Vector2 vector2_2 = Position + new Vector2((float) (Width / 2) - 25f, (float) (Height / 2)) + Minecart._trackMagnetOffset;
|
|
Vector2 vector2_3 = Velocity;
|
|
float num1 = vector2_3.Length();
|
|
vector2_3.Normalize();
|
|
Vector2 vector2_4 = vector2_2;
|
|
Tile tileTrack = (Tile) null;
|
|
bool flag1 = false;
|
|
bool flag2 = true;
|
|
int num2 = -1;
|
|
int num3 = -1;
|
|
int num4 = -1;
|
|
Minecart.TrackState trackState1 = Minecart.TrackState.NoTrack;
|
|
bool flag3 = false;
|
|
bool flag4 = false;
|
|
bool flag5 = false;
|
|
bool flag6 = false;
|
|
Vector2 vector2_5 = Vector2.Zero;
|
|
Vector2 vector2_6 = Vector2.Zero;
|
|
BitsByte bitsByte = new BitsByte();
|
|
while (true)
|
|
{
|
|
int index1 = (int) ((double) vector2_4.X / 16.0);
|
|
int index2 = (int) ((double) vector2_4.Y / 16.0);
|
|
int index3 = (int) vector2_4.X % 16 / 2;
|
|
if (flag2)
|
|
num4 = index3;
|
|
bool flag7 = index3 != num4;
|
|
if ((trackState1 == Minecart.TrackState.OnBack || trackState1 == Minecart.TrackState.OnTrack || trackState1 == Minecart.TrackState.OnFront) && index1 != num2)
|
|
{
|
|
int index4 = trackState1 != Minecart.TrackState.OnBack ? (int) tileTrack.FrontTrack() : (int) tileTrack.BackTrack();
|
|
switch ((double) vector2_3.X >= 0.0 ? Minecart._rightSideConnection[index4] : Minecart._leftSideConnection[index4])
|
|
{
|
|
case 0:
|
|
--index2;
|
|
vector2_4.Y -= 2f;
|
|
break;
|
|
case 2:
|
|
++index2;
|
|
vector2_4.Y += 2f;
|
|
break;
|
|
}
|
|
}
|
|
Minecart.TrackState trackState2 = Minecart.TrackState.NoTrack;
|
|
bool flag8 = false;
|
|
if (index1 != num2 || index2 != num3)
|
|
{
|
|
if (flag2)
|
|
flag2 = false;
|
|
else
|
|
flag8 = true;
|
|
tileTrack = Main.tile[index1, index2];
|
|
if (tileTrack == null)
|
|
{
|
|
tileTrack = new Tile();
|
|
Main.tile[index1, index2] = tileTrack;
|
|
}
|
|
flag1 = tileTrack.nactive() && tileTrack.type == (ushort) 314;
|
|
}
|
|
if (flag1)
|
|
{
|
|
Minecart.TrackState trackState3 = Minecart.TrackState.NoTrack;
|
|
int index5 = (int) tileTrack.FrontTrack();
|
|
int index6 = (int) tileTrack.BackTrack();
|
|
int num5 = Minecart._tileHeight[index5][index3];
|
|
switch (num5)
|
|
{
|
|
case -4:
|
|
if (trackState1 == Minecart.TrackState.OnFront)
|
|
{
|
|
if (trackOnly)
|
|
{
|
|
vector2_4 -= vector2_6;
|
|
num1 = 0.0f;
|
|
trackState2 = Minecart.TrackState.OnFront;
|
|
flag6 = true;
|
|
break;
|
|
}
|
|
trackState2 = Minecart.TrackState.NoTrack;
|
|
flag5 = true;
|
|
break;
|
|
}
|
|
break;
|
|
case -3:
|
|
if (trackState1 == Minecart.TrackState.OnFront)
|
|
{
|
|
trackState1 = Minecart.TrackState.NoTrack;
|
|
Matrix matrix = (double) Velocity.X <= 0.0 ? (Minecart._rightSideConnection[index5] != 2 ? Matrix.CreateRotationZ(-0.7853982f) : Matrix.CreateRotationZ(0.7853982f)) : (Minecart._leftSideConnection[index5] != 2 ? Matrix.CreateRotationZ(0.7853982f) : Matrix.CreateRotationZ(-0.7853982f));
|
|
vector2_5 = Vector2.Transform(new Vector2(Velocity.X, 0.0f), matrix);
|
|
vector2_5.X = Velocity.X;
|
|
flag4 = true;
|
|
num1 = 0.0f;
|
|
break;
|
|
}
|
|
break;
|
|
case -2:
|
|
if (trackState1 == Minecart.TrackState.OnFront)
|
|
{
|
|
if (trackOnly)
|
|
{
|
|
vector2_4 -= vector2_6;
|
|
num1 = 0.0f;
|
|
trackState2 = Minecart.TrackState.OnFront;
|
|
flag6 = true;
|
|
break;
|
|
}
|
|
if ((double) vector2_3.X < 0.0)
|
|
{
|
|
float num6 = (float) (index1 * 16 + (index3 + 1) * 2) - vector2_4.X;
|
|
vector2_4.X += num6;
|
|
num1 += num6 / vector2_3.X;
|
|
}
|
|
vector2_3.X = -vector2_3.X;
|
|
bitsByte[1] = true;
|
|
trackState2 = Minecart.TrackState.OnFront;
|
|
break;
|
|
}
|
|
break;
|
|
case -1:
|
|
if (trackState1 == Minecart.TrackState.OnFront)
|
|
{
|
|
vector2_4 -= vector2_6;
|
|
num1 = 0.0f;
|
|
trackState2 = Minecart.TrackState.OnFront;
|
|
flag6 = true;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
float num7 = (float) (index2 * 16 + num5);
|
|
if (index1 != num2 && trackState1 == Minecart.TrackState.NoTrack && (double) vector2_4.Y > (double) num7 && (double) vector2_4.Y - (double) num7 < 2.0)
|
|
{
|
|
flag8 = false;
|
|
trackState1 = Minecart.TrackState.AboveFront;
|
|
}
|
|
Minecart.TrackState trackState4 = (double) vector2_4.Y >= (double) num7 ? ((double) vector2_4.Y <= (double) num7 ? Minecart.TrackState.OnTrack : Minecart.TrackState.BelowTrack) : Minecart.TrackState.AboveTrack;
|
|
if (index6 != -1)
|
|
{
|
|
float num8 = (float) (index2 * 16 + Minecart._tileHeight[index6][index3]);
|
|
trackState3 = (double) vector2_4.Y >= (double) num8 ? ((double) vector2_4.Y <= (double) num8 ? Minecart.TrackState.OnTrack : Minecart.TrackState.BelowTrack) : Minecart.TrackState.AboveTrack;
|
|
}
|
|
switch (trackState4)
|
|
{
|
|
case Minecart.TrackState.AboveTrack:
|
|
switch (trackState3)
|
|
{
|
|
case Minecart.TrackState.AboveTrack:
|
|
trackState2 = Minecart.TrackState.AboveTrack;
|
|
break;
|
|
case Minecart.TrackState.OnTrack:
|
|
trackState2 = Minecart.TrackState.OnBack;
|
|
break;
|
|
case Minecart.TrackState.BelowTrack:
|
|
trackState2 = Minecart.TrackState.AboveFront;
|
|
break;
|
|
default:
|
|
trackState2 = Minecart.TrackState.AboveFront;
|
|
break;
|
|
}
|
|
break;
|
|
case Minecart.TrackState.OnTrack:
|
|
trackState2 = trackState3 != Minecart.TrackState.OnTrack ? Minecart.TrackState.OnFront : Minecart.TrackState.OnTrack;
|
|
break;
|
|
case Minecart.TrackState.BelowTrack:
|
|
switch (trackState3)
|
|
{
|
|
case Minecart.TrackState.AboveTrack:
|
|
trackState2 = Minecart.TrackState.AboveBack;
|
|
break;
|
|
case Minecart.TrackState.OnTrack:
|
|
trackState2 = Minecart.TrackState.OnBack;
|
|
break;
|
|
case Minecart.TrackState.BelowTrack:
|
|
trackState2 = Minecart.TrackState.BelowTrack;
|
|
break;
|
|
default:
|
|
trackState2 = Minecart.TrackState.BelowTrack;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!flag8)
|
|
{
|
|
if (trackState1 != trackState2)
|
|
{
|
|
bool flag9 = false;
|
|
if (flag7 || (double) vector2_3.Y > 0.0)
|
|
{
|
|
switch (trackState1)
|
|
{
|
|
case Minecart.TrackState.AboveTrack:
|
|
switch (trackState2)
|
|
{
|
|
case Minecart.TrackState.AboveTrack:
|
|
trackState2 = Minecart.TrackState.OnTrack;
|
|
break;
|
|
case Minecart.TrackState.AboveFront:
|
|
trackState2 = Minecart.TrackState.OnBack;
|
|
break;
|
|
case Minecart.TrackState.AboveBack:
|
|
trackState2 = Minecart.TrackState.OnFront;
|
|
break;
|
|
}
|
|
break;
|
|
case Minecart.TrackState.OnTrack:
|
|
int num9 = Minecart._tileHeight[(int) tileTrack.FrontTrack()][index3];
|
|
int num10 = Minecart._tileHeight[(int) tileTrack.BackTrack()][index3];
|
|
trackState2 = !followDown ? (!followUp ? Minecart.TrackState.OnFront : (num9 >= num10 ? Minecart.TrackState.OnBack : Minecart.TrackState.OnFront)) : (num9 >= num10 ? Minecart.TrackState.OnFront : Minecart.TrackState.OnBack);
|
|
flag9 = true;
|
|
break;
|
|
case Minecart.TrackState.AboveFront:
|
|
if (trackState2 == Minecart.TrackState.BelowTrack)
|
|
{
|
|
trackState2 = Minecart.TrackState.OnFront;
|
|
break;
|
|
}
|
|
break;
|
|
case Minecart.TrackState.AboveBack:
|
|
if (trackState2 == Minecart.TrackState.BelowTrack)
|
|
{
|
|
trackState2 = Minecart.TrackState.OnBack;
|
|
break;
|
|
}
|
|
break;
|
|
case Minecart.TrackState.OnFront:
|
|
trackState2 = Minecart.TrackState.OnFront;
|
|
flag9 = true;
|
|
break;
|
|
case Minecart.TrackState.OnBack:
|
|
trackState2 = Minecart.TrackState.OnBack;
|
|
flag9 = true;
|
|
break;
|
|
}
|
|
int index7 = -1;
|
|
if (trackState2 != Minecart.TrackState.OnTrack && trackState2 != Minecart.TrackState.OnFront)
|
|
{
|
|
if (trackState2 == Minecart.TrackState.OnBack)
|
|
index7 = (int) tileTrack.BackTrack();
|
|
}
|
|
else
|
|
index7 = (int) tileTrack.FrontTrack();
|
|
if (index7 != -1)
|
|
{
|
|
if (!flag9 && (double) Velocity.Y > (double) Player.defaultGravity)
|
|
{
|
|
int num11 = (int) ((double) Position.Y / 16.0);
|
|
if (fallStart < num11 - 1)
|
|
{
|
|
delegatesData.MinecartLandingSound(Position, Width, Height);
|
|
Minecart.WheelSparks(delegatesData.MinecartDust, Position, Width, Height, 10);
|
|
}
|
|
}
|
|
if (trackState1 == Minecart.TrackState.AboveFront && Minecart._trackType[index7] == 1)
|
|
flag3 = true;
|
|
vector2_3.Y = 0.0f;
|
|
vector2_4.Y = (float) (index2 * 16 + Minecart._tileHeight[index7][index3]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (trackState2 == Minecart.TrackState.OnFront || trackState2 == Minecart.TrackState.OnBack || trackState2 == Minecart.TrackState.OnTrack)
|
|
{
|
|
if (flag1 && Minecart._trackType[(int) tileTrack.FrontTrack()] == 1)
|
|
flag3 = true;
|
|
vector2_3.Y = 0.0f;
|
|
}
|
|
if (trackState2 == Minecart.TrackState.OnFront)
|
|
{
|
|
int index8 = (int) tileTrack.FrontTrack();
|
|
if (Minecart._trackType[index8] == 2 && (double) lastBoost.X == 0.0 && (double) lastBoost.Y == 0.0)
|
|
{
|
|
lastBoost = new Vector2((float) index1, (float) index2);
|
|
if (Minecart._boostLeft[index8])
|
|
bitsByte[4] = true;
|
|
else
|
|
bitsByte[5] = true;
|
|
}
|
|
}
|
|
num4 = index3;
|
|
trackState1 = trackState2;
|
|
num2 = index1;
|
|
num3 = index2;
|
|
if ((double) num1 > 0.0)
|
|
{
|
|
float num12 = vector2_4.X % 2f;
|
|
float num13 = vector2_4.Y % 2f;
|
|
float num14 = 3f;
|
|
float num15 = 3f;
|
|
if ((double) vector2_3.X < 0.0)
|
|
num14 = num12 + 0.125f;
|
|
else if ((double) vector2_3.X > 0.0)
|
|
num14 = 2f - num12;
|
|
if ((double) vector2_3.Y < 0.0)
|
|
num15 = num13 + 0.125f;
|
|
else if ((double) vector2_3.Y > 0.0)
|
|
num15 = 2f - num13;
|
|
if ((double) num14 != 3.0 || (double) num15 != 3.0)
|
|
{
|
|
float num16 = Math.Abs(num14 / vector2_3.X);
|
|
float num17 = Math.Abs(num15 / vector2_3.Y);
|
|
float num18 = (double) num16 < (double) num17 ? num16 : num17;
|
|
if ((double) num18 > (double) num1)
|
|
{
|
|
vector2_6 = vector2_3 * num1;
|
|
num1 = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
vector2_6 = vector2_3 * num18;
|
|
num1 -= num18;
|
|
}
|
|
vector2_4 += vector2_6;
|
|
}
|
|
else
|
|
goto label_99;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
if ((double) lastBoost.X != (double) num2 || (double) lastBoost.Y != (double) num3)
|
|
lastBoost = Vector2.Zero;
|
|
label_99:
|
|
if (flag3)
|
|
bitsByte[3] = true;
|
|
if (flag5)
|
|
{
|
|
Velocity.X = vector2_4.X - vector2_2.X;
|
|
Velocity.Y = Player.defaultGravity;
|
|
}
|
|
else if (flag4)
|
|
{
|
|
bitsByte[2] = true;
|
|
Velocity = vector2_5;
|
|
}
|
|
else if (bitsByte[1])
|
|
{
|
|
Velocity.X = -Velocity.X;
|
|
Position.X = vector2_4.X - Minecart._trackMagnetOffset.X - vector2_1.X - Velocity.X;
|
|
if ((double) vector2_3.Y == 0.0)
|
|
Velocity.Y = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
if (flag6)
|
|
Velocity.X = vector2_4.X - vector2_2.X;
|
|
if ((double) vector2_3.Y == 0.0)
|
|
Velocity.Y = 0.0f;
|
|
}
|
|
Position.Y += vector2_4.Y - vector2_2.Y - Velocity.Y;
|
|
Position.Y = (float) Math.Round((double) Position.Y, 2);
|
|
switch (trackState1)
|
|
{
|
|
case Minecart.TrackState.OnTrack:
|
|
case Minecart.TrackState.OnFront:
|
|
case Minecart.TrackState.OnBack:
|
|
bitsByte[0] = true;
|
|
break;
|
|
}
|
|
return bitsByte;
|
|
}
|
|
|
|
public static bool FrameTrack(int i, int j, bool pound, bool mute = false)
|
|
{
|
|
if (Minecart._trackType == null)
|
|
return false;
|
|
Tile tileTrack = Main.tile[i, j];
|
|
if (tileTrack == null)
|
|
{
|
|
tileTrack = new Tile();
|
|
Main.tile[i, j] = tileTrack;
|
|
}
|
|
if (mute && tileTrack.type != (ushort) 314)
|
|
return false;
|
|
int tilesSetLookupIndex = Minecart.GetNearbyTilesSetLookupIndex(i, j);
|
|
int index1 = (int) tileTrack.FrontTrack();
|
|
int num1 = (int) tileTrack.BackTrack();
|
|
int num2 = index1 < 0 || index1 >= Minecart._trackType.Length ? 0 : Minecart._trackType[index1];
|
|
int index2 = -1;
|
|
int index3 = -1;
|
|
int[] trackSwitchOption = Minecart._trackSwitchOptions[tilesSetLookupIndex];
|
|
if (trackSwitchOption == null)
|
|
{
|
|
if (pound)
|
|
return false;
|
|
tileTrack.FrontTrack((short) 0);
|
|
tileTrack.BackTrack((short) -1);
|
|
return false;
|
|
}
|
|
if (!pound)
|
|
{
|
|
int num3 = -1;
|
|
int num4 = -1;
|
|
bool flag = false;
|
|
for (int index4 = 0; index4 < trackSwitchOption.Length; ++index4)
|
|
{
|
|
int index5 = trackSwitchOption[index4];
|
|
if (num1 == trackSwitchOption[index4])
|
|
index3 = index4;
|
|
if (Minecart._trackType[index5] == num2)
|
|
{
|
|
if (Minecart._leftSideConnection[index5] == -1 || Minecart._rightSideConnection[index5] == -1)
|
|
{
|
|
if (index1 == trackSwitchOption[index4])
|
|
{
|
|
index2 = index4;
|
|
flag = true;
|
|
}
|
|
if (num3 == -1)
|
|
num3 = index4;
|
|
}
|
|
else
|
|
{
|
|
if (index1 == trackSwitchOption[index4])
|
|
{
|
|
index2 = index4;
|
|
flag = false;
|
|
}
|
|
if (num4 == -1)
|
|
num4 = index4;
|
|
}
|
|
}
|
|
}
|
|
if (num4 != -1)
|
|
{
|
|
if (index2 == -1 | flag)
|
|
index2 = num4;
|
|
}
|
|
else
|
|
{
|
|
if (index2 == -1)
|
|
{
|
|
if (num2 == 2 || num2 == 1)
|
|
return false;
|
|
index2 = num3;
|
|
}
|
|
index3 = -1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int index6 = 0; index6 < trackSwitchOption.Length; ++index6)
|
|
{
|
|
if (index1 == trackSwitchOption[index6])
|
|
index2 = index6;
|
|
if (num1 == trackSwitchOption[index6])
|
|
index3 = index6;
|
|
}
|
|
int num5 = 0;
|
|
int num6 = 0;
|
|
for (int index7 = 0; index7 < trackSwitchOption.Length; ++index7)
|
|
{
|
|
if (Minecart._trackType[trackSwitchOption[index7]] == num2)
|
|
{
|
|
if (Minecart._leftSideConnection[trackSwitchOption[index7]] == -1 || Minecart._rightSideConnection[trackSwitchOption[index7]] == -1)
|
|
++num6;
|
|
else
|
|
++num5;
|
|
}
|
|
}
|
|
if (num5 < 2 && num6 < 2)
|
|
return false;
|
|
bool flag1 = num5 == 0;
|
|
bool flag2 = false;
|
|
if (!flag1)
|
|
{
|
|
while (!flag2)
|
|
{
|
|
++index3;
|
|
if (index3 >= trackSwitchOption.Length)
|
|
{
|
|
index3 = -1;
|
|
break;
|
|
}
|
|
if ((Minecart._leftSideConnection[trackSwitchOption[index3]] != Minecart._leftSideConnection[trackSwitchOption[index2]] || Minecart._rightSideConnection[trackSwitchOption[index3]] != Minecart._rightSideConnection[trackSwitchOption[index2]]) && Minecart._trackType[trackSwitchOption[index3]] == num2 && Minecart._leftSideConnection[trackSwitchOption[index3]] != -1 && Minecart._rightSideConnection[trackSwitchOption[index3]] != -1)
|
|
flag2 = true;
|
|
}
|
|
}
|
|
if (!flag2)
|
|
{
|
|
do
|
|
{
|
|
++index2;
|
|
if (index2 >= trackSwitchOption.Length)
|
|
{
|
|
index2 = -1;
|
|
do
|
|
{
|
|
++index2;
|
|
}
|
|
while (Minecart._trackType[trackSwitchOption[index2]] != num2 || (Minecart._leftSideConnection[trackSwitchOption[index2]] == -1 ? 1 : (Minecart._rightSideConnection[trackSwitchOption[index2]] == -1 ? 1 : 0)) != (flag1 ? 1 : 0));
|
|
break;
|
|
}
|
|
}
|
|
while (Minecart._trackType[trackSwitchOption[index2]] != num2 || (Minecart._leftSideConnection[trackSwitchOption[index2]] == -1 ? 1 : (Minecart._rightSideConnection[trackSwitchOption[index2]] == -1 ? 1 : 0)) != (flag1 ? 1 : 0));
|
|
}
|
|
}
|
|
bool flag3 = false;
|
|
switch (index2)
|
|
{
|
|
case -2:
|
|
if ((int) tileTrack.FrontTrack() != (int) Minecart._firstPressureFrame)
|
|
{
|
|
flag3 = true;
|
|
break;
|
|
}
|
|
break;
|
|
case -1:
|
|
if (tileTrack.FrontTrack() != (short) 0)
|
|
{
|
|
flag3 = true;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
if ((int) tileTrack.FrontTrack() != trackSwitchOption[index2])
|
|
{
|
|
flag3 = true;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
if (index3 == -1)
|
|
{
|
|
if (tileTrack.BackTrack() != (short) -1)
|
|
flag3 = true;
|
|
}
|
|
else if ((int) tileTrack.BackTrack() != trackSwitchOption[index3])
|
|
flag3 = true;
|
|
switch (index2)
|
|
{
|
|
case -2:
|
|
tileTrack.FrontTrack(Minecart._firstPressureFrame);
|
|
break;
|
|
case -1:
|
|
tileTrack.FrontTrack((short) 0);
|
|
break;
|
|
default:
|
|
tileTrack.FrontTrack((short) trackSwitchOption[index2]);
|
|
break;
|
|
}
|
|
if (index3 == -1)
|
|
tileTrack.BackTrack((short) -1);
|
|
else
|
|
tileTrack.BackTrack((short) trackSwitchOption[index3]);
|
|
if (pound & flag3 && !mute)
|
|
WorldGen.KillTile(i, j, true);
|
|
return true;
|
|
}
|
|
|
|
private static int GetNearbyTilesSetLookupIndex(int i, int j)
|
|
{
|
|
int num = 0;
|
|
if (Main.tile[i - 1, j - 1] != null && Main.tile[i - 1, j - 1].type == (ushort) 314)
|
|
++num;
|
|
if (Main.tile[i - 1, j] != null && Main.tile[i - 1, j].type == (ushort) 314)
|
|
num += 2;
|
|
if (Main.tile[i - 1, j + 1] != null && Main.tile[i - 1, j + 1].type == (ushort) 314)
|
|
num += 4;
|
|
if (Main.tile[i + 1, j - 1] != null && Main.tile[i + 1, j - 1].type == (ushort) 314)
|
|
num += 8;
|
|
if (Main.tile[i + 1, j] != null && Main.tile[i + 1, j].type == (ushort) 314)
|
|
num += 16;
|
|
if (Main.tile[i + 1, j + 1] != null && Main.tile[i + 1, j + 1].type == (ushort) 314)
|
|
num += 32;
|
|
return num;
|
|
}
|
|
|
|
public static bool GetOnTrack(
|
|
int tileX,
|
|
int tileY,
|
|
ref Vector2 Position,
|
|
int Width,
|
|
int Height)
|
|
{
|
|
Tile tile = Main.tile[tileX, tileY];
|
|
if (tile.type != (ushort) 314)
|
|
return false;
|
|
Vector2 vector2_1 = new Vector2((float) (Width / 2) - 25f, (float) (Height / 2));
|
|
Vector2 vector2_2 = Position + vector2_1 + Minecart._trackMagnetOffset;
|
|
int num1 = (int) vector2_2.X % 16 / 2;
|
|
int num2 = -1;
|
|
int num3 = 0;
|
|
for (int index = num1; index < 8; ++index)
|
|
{
|
|
num3 = Minecart._tileHeight[(int) tile.frameX][index];
|
|
if (num3 >= 0)
|
|
{
|
|
num2 = index;
|
|
break;
|
|
}
|
|
}
|
|
if (num2 == -1)
|
|
{
|
|
for (int index = num1 - 1; index >= 0; --index)
|
|
{
|
|
num3 = Minecart._tileHeight[(int) tile.frameX][index];
|
|
if (num3 >= 0)
|
|
{
|
|
num2 = index;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (num2 == -1)
|
|
return false;
|
|
vector2_2.X = (float) (tileX * 16 + num2 * 2);
|
|
vector2_2.Y = (float) (tileY * 16 + num3);
|
|
vector2_2 -= Minecart._trackMagnetOffset;
|
|
vector2_2 -= vector2_1;
|
|
Position = vector2_2;
|
|
return true;
|
|
}
|
|
|
|
public static bool OnTrack(Vector2 Position, int Width, int Height)
|
|
{
|
|
Vector2 vector2 = Position + new Vector2((float) (Width / 2) - 25f, (float) (Height / 2)) + Minecart._trackMagnetOffset;
|
|
int index1 = (int) ((double) vector2.X / 16.0);
|
|
int index2 = (int) ((double) vector2.Y / 16.0);
|
|
return Main.tile[index1, index2] != null && Main.tile[index1, index2].type == (ushort) 314;
|
|
}
|
|
|
|
public static float TrackRotation(
|
|
ref float rotation,
|
|
Vector2 Position,
|
|
int Width,
|
|
int Height,
|
|
bool followDown,
|
|
bool followUp,
|
|
Mount.MountDelegatesData delegatesData)
|
|
{
|
|
Vector2 leftWheel;
|
|
Vector2 rightWheel;
|
|
Minecart.GetWheelsPositions(Position, Width, Height, followDown, followUp, delegatesData, out leftWheel, out rightWheel);
|
|
float num1 = rightWheel.Y - leftWheel.Y;
|
|
float num2 = rightWheel.X - leftWheel.X;
|
|
float num3 = num1 / num2;
|
|
double num4 = (double) leftWheel.Y + ((double) Position.X - (double) leftWheel.X) * (double) num3;
|
|
float num5 = (Position.X - (float) (int) Position.X) * num3;
|
|
rotation = (float) Math.Atan2((double) num1, (double) num2);
|
|
double y = (double) Position.Y;
|
|
return (float) (num4 - y) + num5;
|
|
}
|
|
|
|
public static void GetWheelsPositions(
|
|
Vector2 Position,
|
|
int Width,
|
|
int Height,
|
|
bool followDown,
|
|
bool followUp,
|
|
Mount.MountDelegatesData delegatesData,
|
|
out Vector2 leftWheel,
|
|
out Vector2 rightWheel)
|
|
{
|
|
leftWheel = Position;
|
|
rightWheel = Position;
|
|
Vector2 zero = Vector2.Zero;
|
|
Vector2 Velocity = new Vector2(-12f, 0.0f);
|
|
Minecart.TrackCollision(ref leftWheel, ref Velocity, ref zero, Width, Height, followDown, followUp, 0, true, delegatesData);
|
|
leftWheel += Velocity;
|
|
Velocity = new Vector2(12f, 0.0f);
|
|
Minecart.TrackCollision(ref rightWheel, ref Velocity, ref zero, Width, Height, followDown, followUp, 0, true, delegatesData);
|
|
rightWheel += Velocity;
|
|
}
|
|
|
|
public static void HitTrackSwitch(Vector2 Position, int Width, int Height)
|
|
{
|
|
Vector2 magnetPosition = Minecart.GetMagnetPosition(Position, Width, Height);
|
|
int num = (int) ((double) magnetPosition.X / 16.0);
|
|
int j = (int) ((double) magnetPosition.Y / 16.0);
|
|
Wiring.HitSwitch(num, j);
|
|
NetMessage.SendData(59, number: num, number2: ((float) j));
|
|
}
|
|
|
|
public static Vector2 GetMagnetPosition(Vector2 Position, int Width, int Height)
|
|
{
|
|
Vector2 vector2 = new Vector2((float) (Width / 2) - 25f, (float) (Height / 2));
|
|
return Position + new Vector2((float) (Width / 2) - 25f, (float) (Height / 2)) + Minecart._trackMagnetOffset;
|
|
}
|
|
|
|
public static void FlipSwitchTrack(int i, int j)
|
|
{
|
|
Tile tileTrack = Main.tile[i, j];
|
|
short trackID = tileTrack.FrontTrack();
|
|
if (trackID == (short) -1)
|
|
return;
|
|
switch (Minecart._trackType[(int) trackID])
|
|
{
|
|
case 0:
|
|
if (tileTrack.BackTrack() == (short) -1)
|
|
break;
|
|
tileTrack.FrontTrack(tileTrack.BackTrack());
|
|
tileTrack.BackTrack(trackID);
|
|
NetMessage.SendTileSquare(-1, i, j, 1);
|
|
break;
|
|
case 2:
|
|
Minecart.FrameTrack(i, j, true, true);
|
|
NetMessage.SendTileSquare(-1, i, j, 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public static void TrackColors(
|
|
int i,
|
|
int j,
|
|
Tile trackTile,
|
|
out int frontColor,
|
|
out int backColor)
|
|
{
|
|
if (trackTile.type == (ushort) 314)
|
|
{
|
|
frontColor = (int) trackTile.color();
|
|
backColor = frontColor;
|
|
if (trackTile.frameY == (short) -1)
|
|
return;
|
|
int num1 = Minecart._leftSideConnection[(int) trackTile.frameX];
|
|
int num2 = Minecart._rightSideConnection[(int) trackTile.frameX];
|
|
int num3 = Minecart._leftSideConnection[(int) trackTile.frameY];
|
|
int num4 = Minecart._rightSideConnection[(int) trackTile.frameY];
|
|
int num5 = 0;
|
|
int num6 = 0;
|
|
int num7 = 0;
|
|
int num8 = 0;
|
|
for (int index = 0; index < 4; ++index)
|
|
{
|
|
int num9;
|
|
switch (index - 1)
|
|
{
|
|
case 0:
|
|
num9 = num2;
|
|
break;
|
|
case 1:
|
|
num9 = num3;
|
|
break;
|
|
case 2:
|
|
num9 = num4;
|
|
break;
|
|
default:
|
|
num9 = num1;
|
|
break;
|
|
}
|
|
int num10;
|
|
switch (num9)
|
|
{
|
|
case 0:
|
|
num10 = -1;
|
|
break;
|
|
case 1:
|
|
num10 = 0;
|
|
break;
|
|
case 2:
|
|
num10 = 1;
|
|
break;
|
|
default:
|
|
num10 = 0;
|
|
break;
|
|
}
|
|
Tile tile = index % 2 != 0 ? Main.tile[i + 1, j + num10] : Main.tile[i - 1, j + num10];
|
|
int num11 = tile == null || !tile.active() || tile.type != (ushort) 314 ? 0 : (int) tile.color();
|
|
switch (index)
|
|
{
|
|
case 1:
|
|
num6 = num11;
|
|
break;
|
|
case 2:
|
|
num7 = num11;
|
|
break;
|
|
case 3:
|
|
num8 = num11;
|
|
break;
|
|
default:
|
|
num5 = num11;
|
|
break;
|
|
}
|
|
}
|
|
if (num1 == num3)
|
|
{
|
|
if (num6 != 0)
|
|
frontColor = num6;
|
|
else if (num5 != 0)
|
|
frontColor = num5;
|
|
if (num8 != 0)
|
|
{
|
|
backColor = num8;
|
|
}
|
|
else
|
|
{
|
|
if (num7 == 0)
|
|
return;
|
|
backColor = num7;
|
|
}
|
|
}
|
|
else if (num2 == num4)
|
|
{
|
|
if (num5 != 0)
|
|
frontColor = num5;
|
|
else if (num6 != 0)
|
|
frontColor = num6;
|
|
if (num7 != 0)
|
|
{
|
|
backColor = num7;
|
|
}
|
|
else
|
|
{
|
|
if (num8 == 0)
|
|
return;
|
|
backColor = num8;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (num6 == 0)
|
|
{
|
|
if (num5 != 0)
|
|
frontColor = num5;
|
|
}
|
|
else if (num5 != 0)
|
|
frontColor = num2 <= num1 ? num6 : num5;
|
|
if (num8 == 0)
|
|
{
|
|
if (num7 == 0)
|
|
return;
|
|
backColor = num7;
|
|
}
|
|
else
|
|
{
|
|
if (num7 == 0)
|
|
return;
|
|
backColor = num4 <= num3 ? num8 : num7;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
frontColor = 0;
|
|
backColor = 0;
|
|
}
|
|
}
|
|
|
|
public static bool DrawLeftDecoration(int frameID) => frameID >= 0 && frameID < 36 && Minecart._leftSideConnection[frameID] == 2;
|
|
|
|
public static bool DrawRightDecoration(int frameID) => frameID >= 0 && frameID < 36 && Minecart._rightSideConnection[frameID] == 2;
|
|
|
|
public static bool DrawBumper(int frameID)
|
|
{
|
|
if (frameID < 0 || frameID >= 36)
|
|
return false;
|
|
return Minecart._tileHeight[frameID][0] == -1 || Minecart._tileHeight[frameID][7] == -1;
|
|
}
|
|
|
|
public static bool DrawBouncyBumper(int frameID)
|
|
{
|
|
if (frameID < 0 || frameID >= 36)
|
|
return false;
|
|
return Minecart._tileHeight[frameID][0] == -2 || Minecart._tileHeight[frameID][7] == -2;
|
|
}
|
|
|
|
public static void PlaceTrack(Tile trackCache, int style)
|
|
{
|
|
trackCache.active(true);
|
|
trackCache.type = (ushort) 314;
|
|
trackCache.frameY = (short) -1;
|
|
switch (style)
|
|
{
|
|
case 0:
|
|
trackCache.frameX = (short) -1;
|
|
break;
|
|
case 1:
|
|
trackCache.frameX = Minecart._firstPressureFrame;
|
|
break;
|
|
case 2:
|
|
trackCache.frameX = Minecart._firstLeftBoostFrame;
|
|
break;
|
|
case 3:
|
|
trackCache.frameX = Minecart._firstRightBoostFrame;
|
|
break;
|
|
}
|
|
}
|
|
|
|
public static int GetTrackItem(Tile trackCache)
|
|
{
|
|
switch (Minecart._trackType[(int) trackCache.frameX])
|
|
{
|
|
case 0:
|
|
return 2340;
|
|
case 1:
|
|
return 2492;
|
|
case 2:
|
|
return 2739;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public static Rectangle GetSourceRect(int frameID, int animationFrame = 0)
|
|
{
|
|
if (frameID < 0 || frameID >= 40)
|
|
return new Rectangle(0, 0, 0, 0);
|
|
Vector2 vector2 = Minecart._texturePosition[frameID];
|
|
Rectangle rectangle = new Rectangle((int) vector2.X, (int) vector2.Y, 16, 16);
|
|
if (frameID < 36 && Minecart._trackType[frameID] == 2)
|
|
rectangle.Y += 18 * animationFrame;
|
|
return rectangle;
|
|
}
|
|
|
|
public static bool GetAreExpectationsForSidesMet(
|
|
Point tileCoords,
|
|
int? expectedYOffsetForLeft,
|
|
int? expectedYOffsetForRight)
|
|
{
|
|
Tile tileTrack = Main.tile[tileCoords.X, tileCoords.Y];
|
|
if (expectedYOffsetForLeft.HasValue)
|
|
{
|
|
short num1 = tileTrack.FrontTrack();
|
|
int num2 = Minecart.ConvertOffsetYToTrackConnectionValue(expectedYOffsetForLeft.Value);
|
|
if (Minecart._leftSideConnection[(int) num1] != num2)
|
|
return false;
|
|
}
|
|
if (expectedYOffsetForRight.HasValue)
|
|
{
|
|
short num3 = tileTrack.FrontTrack();
|
|
int num4 = Minecart.ConvertOffsetYToTrackConnectionValue(expectedYOffsetForRight.Value);
|
|
if (Minecart._rightSideConnection[(int) num3] != num4)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static void TryFittingTileOrientation(
|
|
Point tileCoords,
|
|
int? expectedYOffsetForLeft,
|
|
int? expectedYOffsetForRight)
|
|
{
|
|
int tilesSetLookupIndex = Minecart.GetNearbyTilesSetLookupIndex(tileCoords.X, tileCoords.Y);
|
|
int[] trackSwitchOption = Minecart._trackSwitchOptions[tilesSetLookupIndex];
|
|
if (trackSwitchOption == null)
|
|
return;
|
|
Tile tileSafely = Framing.GetTileSafely(tileCoords);
|
|
int num1 = Minecart._trackType[(int) tileSafely.FrontTrack()];
|
|
int? nullable = new int?();
|
|
for (int index1 = 0; index1 < trackSwitchOption.Length; ++index1)
|
|
{
|
|
int index2 = trackSwitchOption[index1];
|
|
int num2 = Minecart._leftSideConnection[index2];
|
|
int num3 = Minecart._rightSideConnection[index2];
|
|
int num4 = Minecart._trackType[index2];
|
|
if (expectedYOffsetForLeft.HasValue)
|
|
{
|
|
int num5 = Minecart.ConvertOffsetYToTrackConnectionValue(expectedYOffsetForLeft.Value);
|
|
if (Minecart._leftSideConnection[index2] != num5)
|
|
continue;
|
|
}
|
|
if (expectedYOffsetForRight.HasValue)
|
|
{
|
|
int num6 = Minecart.ConvertOffsetYToTrackConnectionValue(expectedYOffsetForRight.Value);
|
|
if (Minecart._rightSideConnection[index2] != num6)
|
|
continue;
|
|
}
|
|
if (Minecart._trackType[index2] == num1)
|
|
{
|
|
nullable = new int?(index2);
|
|
break;
|
|
}
|
|
}
|
|
if (!nullable.HasValue)
|
|
return;
|
|
tileSafely.FrontTrack((short) nullable.Value);
|
|
NetMessage.SendTileSquare(-1, tileCoords.X, tileCoords.Y, 1);
|
|
}
|
|
|
|
private static int ConvertOffsetYToTrackConnectionValue(int offsetY)
|
|
{
|
|
if (offsetY == -1)
|
|
return 0;
|
|
return offsetY != 1 ? 1 : 2;
|
|
}
|
|
|
|
private static int ConvertTrackConnectionValueToOffsetY(int trackConnectionValue)
|
|
{
|
|
if (trackConnectionValue == 0)
|
|
return -1;
|
|
return trackConnectionValue != 2 ? 0 : 1;
|
|
}
|
|
|
|
public static void WheelSparks(
|
|
Action<Vector2> DustAction,
|
|
Vector2 Position,
|
|
int Width,
|
|
int Height,
|
|
int sparkCount)
|
|
{
|
|
Vector2 vector2_1 = new Vector2((float) (Width / 2) - 25f, (float) (Height / 2));
|
|
Vector2 vector2_2 = Position + vector2_1 + Minecart._trackMagnetOffset;
|
|
for (int index = 0; index < sparkCount; ++index)
|
|
DustAction(vector2_2);
|
|
}
|
|
|
|
private static short FrontTrack(this Tile tileTrack) => tileTrack.frameX;
|
|
|
|
private static void FrontTrack(this Tile tileTrack, short trackID) => tileTrack.frameX = trackID;
|
|
|
|
private static short BackTrack(this Tile tileTrack) => tileTrack.frameY;
|
|
|
|
private static void BackTrack(this Tile tileTrack, short trackID) => tileTrack.frameY = trackID;
|
|
|
|
private enum TrackState
|
|
{
|
|
NoTrack = -1, // 0xFFFFFFFF
|
|
AboveTrack = 0,
|
|
OnTrack = 1,
|
|
BelowTrack = 2,
|
|
AboveFront = 3,
|
|
AboveBack = 4,
|
|
OnFront = 5,
|
|
OnBack = 6,
|
|
}
|
|
}
|
|
}
|