okseby/terraria-source-code
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Terraria 1.3.5.3 Source Code

Browse source
This commit is contained in:
MikeyIsBaeYT 2021-10-27 18:03:19 -04:00
commit 4b21dac4b6
503 changed files with 409032 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

279
GameContent/Generation/TrackGenerator.cs Normal file
View file

@ -0,0 +1,279 @@
// Decompiled with JetBrains decompiler
// Type: Terraria.GameContent.Generation.TrackGenerator
// Assembly: Terraria, Version=1.3.5.3, Culture=neutral, PublicKeyToken=null
// MVID: 68659D26-2BE6-448F-8663-74FA559E6F08
// Assembly location: C:\Users\mikeyisbaeyt\Downloads\depotdownloader-2.4.5\depots\105601\6707058\Terraria.exe
using Microsoft.Xna.Framework;
using System;
using Terraria.ID;
using Terraria.World.Generation;
namespace Terraria.GameContent.Generation
{
public class TrackGenerator
{
private static readonly byte[] INVALID_WALLS = new byte[13]
{
(byte) 7,
(byte) 94,
(byte) 95,
(byte) 8,
(byte) 98,
(byte) 99,
(byte) 9,
(byte) 96,
(byte) 97,
(byte) 3,
(byte) 83,
(byte) 87,
(byte) 86
};
private const int TOTAL_TILE_IGNORES = 150;
private const int PLAYER_HEIGHT = 6;
private const int MAX_RETRIES = 400;
private const int MAX_SMOOTH_DISTANCE = 15;
private const int MAX_ITERATIONS = 1000000;
private TrackGenerator.TrackHistory[] _historyCache = new TrackGenerator.TrackHistory[2048];
public void Generate(int trackCount, int minimumLength)
{
int num = trackCount;
while (num > 0)
{
int x = WorldGen.genRand.Next(150, Main.maxTilesX - 150);
int y = WorldGen.genRand.Next((int) Main.worldSurface + 25, Main.maxTilesY - 200);
if (this.IsLocationEmpty(x, y))
{
while (this.IsLocationEmpty(x, y + 1))
++y;
if (this.FindPath(x, y, minimumLength))
--num;
}
}
}
private bool IsLocationEmpty(int x, int y)
{
if (y > Main.maxTilesY - 200 || x < 0 || y < (int) Main.worldSurface || x > Main.maxTilesX - 5)
return false;
for (int index = 0; index < 6; ++index)
{
if (WorldGen.SolidTile(x, y - index))
return false;
}
return true;
}
private bool CanTrackBePlaced(int x, int y)
{
if (y > Main.maxTilesY - 200 || x < 0 || y < (int) Main.worldSurface || x > Main.maxTilesX - 5)
return false;
byte wall = Main.tile[x, y].wall;
for (int index = 0; index < TrackGenerator.INVALID_WALLS.Length; ++index)
{
if ((int) wall == (int) TrackGenerator.INVALID_WALLS[index])
return false;
}
for (int index = -1; index <= 1; ++index)
{
if (Main.tile[x + index, y].active() && (Main.tile[x + index, y].type == (ushort) 314 || !TileID.Sets.GeneralPlacementTiles[(int) Main.tile[x + index, y].type]))
return false;
}
return true;
}
private void SmoothTrack(TrackGenerator.TrackHistory[] history, int length)
{
int val2 = length - 1;
bool flag = false;
for (int index1 = length - 1; index1 >= 0; --index1)
{
if (flag)
{
val2 = Math.Min(index1 + 15, val2);
if ((int) history[index1].Y >= (int) history[val2].Y)
{
for (int index2 = index1 + 1; (int) history[index2].Y > (int) history[index1].Y; ++index2)
history[index2].Y = history[index1].Y;
if ((int) history[index1].Y == (int) history[val2].Y)
flag = false;
}
}
else if ((int) history[index1].Y > (int) history[val2].Y)
flag = true;
else
val2 = index1;
}
}
public bool FindPath(int x, int y, int minimumLength, bool debugMode = false)
{
TrackGenerator.TrackHistory[] historyCache = this._historyCache;
int index1 = 0;
Tile[,] tile = Main.tile;
bool flag1 = true;
int num1 = WorldGen.genRand.Next(2) == 0 ? 1 : -1;
if (debugMode)
num1 = Main.player[Main.myPlayer].direction;
int yDirection = 1;
int length = 0;
int num2 = 400;
bool flag2 = false;
int num3 = 150;
int num4 = 0;
for (int index2 = 1000000; index2 > 0 & flag1 && index1 < historyCache.Length - 1; ++index1)
{
--index2;
historyCache[index1] = new TrackGenerator.TrackHistory(x, y, yDirection);
bool flag3 = false;
int num5 = 1;
if (index1 > minimumLength >> 1)
num5 = -1;
else if (index1 > (minimumLength >> 1) - 5)
num5 = 0;
if (flag2)
{
int num6 = 0;
int num7 = num3;
bool flag4 = false;
for (int index3 = Math.Min(1, yDirection + 1); index3 >= Math.Max(-1, yDirection - 1); --index3)
{
int num8;
for (num8 = 0; num8 <= num3; ++num8)
{
if (this.IsLocationEmpty(x + (num8 + 1) * num1, y + (num8 + 1) * index3 * num5))
{
flag4 = true;
break;
}
}
if (num8 < num7)
{
num7 = num8;
num6 = index3;
}
}
if (flag4)
{
yDirection = num6;
for (int index4 = 0; index4 < num7 - 1; ++index4)
{
++index1;
x += num1;
y += yDirection * num5;
historyCache[index1] = new TrackGenerator.TrackHistory(x, y, yDirection);
num4 = index1;
}
x += num1;
y += yDirection * num5;
length = index1 + 1;
flag2 = false;
}
num3 -= num7;
if (num3 < 0)
flag1 = false;
}
else
{
for (int index5 = Math.Min(1, yDirection + 1); index5 >= Math.Max(-1, yDirection - 1); --index5)
{
if (this.IsLocationEmpty(x + num1, y + index5 * num5))
{
yDirection = index5;
flag3 = true;
x += num1;
y += yDirection * num5;
length = index1 + 1;
break;
}
}
if (!flag3)
{
while (index1 > num4 && y == (int) historyCache[index1].Y)
--index1;
x = (int) historyCache[index1].X;
y = (int) historyCache[index1].Y;
yDirection = (int) historyCache[index1].YDirection - 1;
--num2;
if (num2 <= 0)
{
index1 = length;
x = (int) historyCache[index1].X;
y = (int) historyCache[index1].Y;
yDirection = (int) historyCache[index1].YDirection;
flag2 = true;
num2 = 200;
}
--index1;
}
}
}
if (!(length > minimumLength | debugMode))
return false;
this.SmoothTrack(historyCache, length);
if (!debugMode)
{
for (int index6 = 0; index6 < length; ++index6)
{
for (int index7 = -1; index7 < 7; ++index7)
{
if (!this.CanTrackBePlaced((int) historyCache[index6].X, (int) historyCache[index6].Y - index7))
return false;
}
}
}
for (int index8 = 0; index8 < length; ++index8)
{
TrackGenerator.TrackHistory trackHistory = historyCache[index8];
for (int index9 = 0; index9 < 6; ++index9)
Main.tile[(int) trackHistory.X, (int) trackHistory.Y - index9].active(false);
}
for (int index10 = 0; index10 < length; ++index10)
{
TrackGenerator.TrackHistory trackHistory = historyCache[index10];
Tile.SmoothSlope((int) trackHistory.X, (int) trackHistory.Y + 1);
Tile.SmoothSlope((int) trackHistory.X, (int) trackHistory.Y - 6);
bool wire = Main.tile[(int) trackHistory.X, (int) trackHistory.Y].wire();
Main.tile[(int) trackHistory.X, (int) trackHistory.Y].ResetToType((ushort) 314);
Main.tile[(int) trackHistory.X, (int) trackHistory.Y].wire(wire);
if (index10 != 0)
{
for (int index11 = 0; index11 < 6; ++index11)
WorldUtils.TileFrame((int) historyCache[index10 - 1].X, (int) historyCache[index10 - 1].Y - index11, true);
if (index10 == length - 1)
{
for (int index12 = 0; index12 < 6; ++index12)
WorldUtils.TileFrame((int) trackHistory.X, (int) trackHistory.Y - index12, true);
}
}
}
return true;
}
public static void Run(int trackCount = 30, int minimumLength = 250) => new TrackGenerator().Generate(trackCount, minimumLength);
public static void Run(Point start) => new TrackGenerator().FindPath(start.X, start.Y, 250, true);
private struct TrackHistory
{
public short X;
public short Y;
public byte YDirection;
public TrackHistory(int x, int y, int yDirection)
{
this.X = (short) x;
this.Y = (short) y;
this.YDirection = (byte) yDirection;
}
public TrackHistory(short x, short y, byte yDirection)
{
this.X = x;
this.Y = y;
this.YDirection = yDirection;
}
}
}
}