469 lines
14 KiB
C#
469 lines
14 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Terraria.WorldBuilding.Modifiers
|
|
// 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;
|
|
|
|
namespace Terraria.WorldBuilding
|
|
{
|
|
public static class Modifiers
|
|
{
|
|
public class ShapeScale : GenAction
|
|
{
|
|
private int _scale;
|
|
|
|
public ShapeScale(int scale) => this._scale = scale;
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
bool flag = false;
|
|
for (int index1 = 0; index1 < this._scale; ++index1)
|
|
{
|
|
for (int index2 = 0; index2 < this._scale; ++index2)
|
|
flag |= !this.UnitApply(origin, (x - origin.X << 1) + index1 + origin.X, (y - origin.Y << 1) + index2 + origin.Y);
|
|
}
|
|
return !flag;
|
|
}
|
|
}
|
|
|
|
public class Expand : GenAction
|
|
{
|
|
private int _xExpansion;
|
|
private int _yExpansion;
|
|
|
|
public Expand(int expansion)
|
|
{
|
|
this._xExpansion = expansion;
|
|
this._yExpansion = expansion;
|
|
}
|
|
|
|
public Expand(int xExpansion, int yExpansion)
|
|
{
|
|
this._xExpansion = xExpansion;
|
|
this._yExpansion = yExpansion;
|
|
}
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
bool flag = false;
|
|
for (int index1 = -this._xExpansion; index1 <= this._xExpansion; ++index1)
|
|
{
|
|
for (int index2 = -this._yExpansion; index2 <= this._yExpansion; ++index2)
|
|
flag |= !this.UnitApply(origin, x + index1, y + index2, args);
|
|
}
|
|
return !flag;
|
|
}
|
|
}
|
|
|
|
public class RadialDither : GenAction
|
|
{
|
|
private float _innerRadius;
|
|
private float _outerRadius;
|
|
|
|
public RadialDither(float innerRadius, float outerRadius)
|
|
{
|
|
this._innerRadius = innerRadius;
|
|
this._outerRadius = outerRadius;
|
|
}
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
Vector2 vector2 = new Vector2((float) origin.X, (float) origin.Y);
|
|
float num = Math.Max(0.0f, Math.Min(1f, (float) (((double) Vector2.Distance(new Vector2((float) x, (float) y), vector2) - (double) this._innerRadius) / ((double) this._outerRadius - (double) this._innerRadius))));
|
|
return GenBase._random.NextDouble() > (double) num ? this.UnitApply(origin, x, y, args) : this.Fail();
|
|
}
|
|
}
|
|
|
|
public class Blotches : GenAction
|
|
{
|
|
private int _minX;
|
|
private int _minY;
|
|
private int _maxX;
|
|
private int _maxY;
|
|
private double _chance;
|
|
|
|
public Blotches(int scale = 2, double chance = 0.3)
|
|
{
|
|
this._minX = scale;
|
|
this._minY = scale;
|
|
this._maxX = scale;
|
|
this._maxY = scale;
|
|
this._chance = chance;
|
|
}
|
|
|
|
public Blotches(int xScale, int yScale, double chance = 0.3)
|
|
{
|
|
this._minX = xScale;
|
|
this._maxX = xScale;
|
|
this._minY = yScale;
|
|
this._maxY = yScale;
|
|
this._chance = chance;
|
|
}
|
|
|
|
public Blotches(int leftScale, int upScale, int rightScale, int downScale, double chance = 0.3)
|
|
{
|
|
this._minX = leftScale;
|
|
this._maxX = rightScale;
|
|
this._minY = upScale;
|
|
this._maxY = downScale;
|
|
this._chance = chance;
|
|
}
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
GenBase._random.NextDouble();
|
|
if (GenBase._random.NextDouble() >= this._chance)
|
|
return this.UnitApply(origin, x, y, args);
|
|
bool flag = false;
|
|
int num1 = GenBase._random.Next(1 - this._minX, 1);
|
|
int num2 = GenBase._random.Next(0, this._maxX);
|
|
int num3 = GenBase._random.Next(1 - this._minY, 1);
|
|
int num4 = GenBase._random.Next(0, this._maxY);
|
|
for (int index1 = num1; index1 <= num2; ++index1)
|
|
{
|
|
for (int index2 = num3; index2 <= num4; ++index2)
|
|
flag |= !this.UnitApply(origin, x + index1, y + index2, args);
|
|
}
|
|
return !flag;
|
|
}
|
|
}
|
|
|
|
public class InShape : GenAction
|
|
{
|
|
private readonly ShapeData _shapeData;
|
|
|
|
public InShape(ShapeData shapeData) => this._shapeData = shapeData;
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args) => !this._shapeData.Contains(x - origin.X, y - origin.Y) ? this.Fail() : this.UnitApply(origin, x, y, args);
|
|
}
|
|
|
|
public class NotInShape : GenAction
|
|
{
|
|
private readonly ShapeData _shapeData;
|
|
|
|
public NotInShape(ShapeData shapeData) => this._shapeData = shapeData;
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args) => this._shapeData.Contains(x - origin.X, y - origin.Y) ? this.Fail() : this.UnitApply(origin, x, y, args);
|
|
}
|
|
|
|
public class Conditions : GenAction
|
|
{
|
|
private readonly GenCondition[] _conditions;
|
|
|
|
public Conditions(params GenCondition[] conditions) => this._conditions = conditions;
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
bool flag = true;
|
|
for (int index = 0; index < this._conditions.Length; ++index)
|
|
flag &= this._conditions[index].IsValid(x, y);
|
|
return flag ? this.UnitApply(origin, x, y, args) : this.Fail();
|
|
}
|
|
}
|
|
|
|
public class OnlyWalls : GenAction
|
|
{
|
|
private ushort[] _types;
|
|
|
|
public OnlyWalls(params ushort[] types) => this._types = types;
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
for (int index = 0; index < this._types.Length; ++index)
|
|
{
|
|
if ((int) GenBase._tiles[x, y].wall == (int) this._types[index])
|
|
return this.UnitApply(origin, x, y, args);
|
|
}
|
|
return this.Fail();
|
|
}
|
|
}
|
|
|
|
public class OnlyTiles : GenAction
|
|
{
|
|
private ushort[] _types;
|
|
|
|
public OnlyTiles(params ushort[] types) => this._types = types;
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
if (!GenBase._tiles[x, y].active())
|
|
return this.Fail();
|
|
for (int index = 0; index < this._types.Length; ++index)
|
|
{
|
|
if ((int) GenBase._tiles[x, y].type == (int) this._types[index])
|
|
return this.UnitApply(origin, x, y, args);
|
|
}
|
|
return this.Fail();
|
|
}
|
|
}
|
|
|
|
public class IsTouching : GenAction
|
|
{
|
|
private static readonly int[] DIRECTIONS = new int[16]
|
|
{
|
|
0,
|
|
-1,
|
|
1,
|
|
0,
|
|
-1,
|
|
0,
|
|
0,
|
|
1,
|
|
-1,
|
|
-1,
|
|
1,
|
|
-1,
|
|
-1,
|
|
1,
|
|
1,
|
|
1
|
|
};
|
|
private bool _useDiagonals;
|
|
private ushort[] _tileIds;
|
|
|
|
public IsTouching(bool useDiagonals, params ushort[] tileIds)
|
|
{
|
|
this._useDiagonals = useDiagonals;
|
|
this._tileIds = tileIds;
|
|
}
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
int num = this._useDiagonals ? 16 : 8;
|
|
for (int index1 = 0; index1 < num; index1 += 2)
|
|
{
|
|
Tile tile = GenBase._tiles[x + Modifiers.IsTouching.DIRECTIONS[index1], y + Modifiers.IsTouching.DIRECTIONS[index1 + 1]];
|
|
if (tile.active())
|
|
{
|
|
for (int index2 = 0; index2 < this._tileIds.Length; ++index2)
|
|
{
|
|
if ((int) tile.type == (int) this._tileIds[index2])
|
|
return this.UnitApply(origin, x, y, args);
|
|
}
|
|
}
|
|
}
|
|
return this.Fail();
|
|
}
|
|
}
|
|
|
|
public class NotTouching : GenAction
|
|
{
|
|
private static readonly int[] DIRECTIONS = new int[16]
|
|
{
|
|
0,
|
|
-1,
|
|
1,
|
|
0,
|
|
-1,
|
|
0,
|
|
0,
|
|
1,
|
|
-1,
|
|
-1,
|
|
1,
|
|
-1,
|
|
-1,
|
|
1,
|
|
1,
|
|
1
|
|
};
|
|
private bool _useDiagonals;
|
|
private ushort[] _tileIds;
|
|
|
|
public NotTouching(bool useDiagonals, params ushort[] tileIds)
|
|
{
|
|
this._useDiagonals = useDiagonals;
|
|
this._tileIds = tileIds;
|
|
}
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
int num = this._useDiagonals ? 16 : 8;
|
|
for (int index1 = 0; index1 < num; index1 += 2)
|
|
{
|
|
Tile tile = GenBase._tiles[x + Modifiers.NotTouching.DIRECTIONS[index1], y + Modifiers.NotTouching.DIRECTIONS[index1 + 1]];
|
|
if (tile.active())
|
|
{
|
|
for (int index2 = 0; index2 < this._tileIds.Length; ++index2)
|
|
{
|
|
if ((int) tile.type == (int) this._tileIds[index2])
|
|
return this.Fail();
|
|
}
|
|
}
|
|
}
|
|
return this.UnitApply(origin, x, y, args);
|
|
}
|
|
}
|
|
|
|
public class IsTouchingAir : GenAction
|
|
{
|
|
private static readonly int[] DIRECTIONS = new int[16]
|
|
{
|
|
0,
|
|
-1,
|
|
1,
|
|
0,
|
|
-1,
|
|
0,
|
|
0,
|
|
1,
|
|
-1,
|
|
-1,
|
|
1,
|
|
-1,
|
|
-1,
|
|
1,
|
|
1,
|
|
1
|
|
};
|
|
private bool _useDiagonals;
|
|
|
|
public IsTouchingAir(bool useDiagonals = false) => this._useDiagonals = useDiagonals;
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
int num = this._useDiagonals ? 16 : 8;
|
|
for (int index = 0; index < num; index += 2)
|
|
{
|
|
if (!GenBase._tiles[x + Modifiers.IsTouchingAir.DIRECTIONS[index], y + Modifiers.IsTouchingAir.DIRECTIONS[index + 1]].active())
|
|
return this.UnitApply(origin, x, y, args);
|
|
}
|
|
return this.Fail();
|
|
}
|
|
}
|
|
|
|
public class SkipTiles : GenAction
|
|
{
|
|
private ushort[] _types;
|
|
|
|
public SkipTiles(params ushort[] types) => this._types = types;
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
if (!GenBase._tiles[x, y].active())
|
|
return this.UnitApply(origin, x, y, args);
|
|
for (int index = 0; index < this._types.Length; ++index)
|
|
{
|
|
if ((int) GenBase._tiles[x, y].type == (int) this._types[index])
|
|
return this.Fail();
|
|
}
|
|
return this.UnitApply(origin, x, y, args);
|
|
}
|
|
}
|
|
|
|
public class HasLiquid : GenAction
|
|
{
|
|
private int _liquidType;
|
|
private int _liquidLevel;
|
|
|
|
public HasLiquid(int liquidLevel = -1, int liquidType = -1)
|
|
{
|
|
this._liquidType = liquidType;
|
|
this._liquidLevel = liquidLevel;
|
|
}
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
Tile tile = GenBase._tiles[x, y];
|
|
return (this._liquidType == -1 || this._liquidType == (int) tile.liquidType()) && (this._liquidLevel == -1 && tile.liquid != (byte) 0 || this._liquidLevel == (int) tile.liquid) ? this.UnitApply(origin, x, y, args) : this.Fail();
|
|
}
|
|
}
|
|
|
|
public class SkipWalls : GenAction
|
|
{
|
|
private ushort[] _types;
|
|
|
|
public SkipWalls(params ushort[] types) => this._types = types;
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
for (int index = 0; index < this._types.Length; ++index)
|
|
{
|
|
if ((int) GenBase._tiles[x, y].wall == (int) this._types[index])
|
|
return this.Fail();
|
|
}
|
|
return this.UnitApply(origin, x, y, args);
|
|
}
|
|
}
|
|
|
|
public class IsEmpty : GenAction
|
|
{
|
|
public override bool Apply(Point origin, int x, int y, params object[] args) => !GenBase._tiles[x, y].active() ? this.UnitApply(origin, x, y, args) : this.Fail();
|
|
}
|
|
|
|
public class IsSolid : GenAction
|
|
{
|
|
public override bool Apply(Point origin, int x, int y, params object[] args) => GenBase._tiles[x, y].active() && WorldGen.SolidOrSlopedTile(x, y) ? this.UnitApply(origin, x, y, args) : this.Fail();
|
|
}
|
|
|
|
public class IsNotSolid : GenAction
|
|
{
|
|
public override bool Apply(Point origin, int x, int y, params object[] args) => !GenBase._tiles[x, y].active() || !WorldGen.SolidOrSlopedTile(x, y) ? this.UnitApply(origin, x, y, args) : this.Fail();
|
|
}
|
|
|
|
public class RectangleMask : GenAction
|
|
{
|
|
private int _xMin;
|
|
private int _yMin;
|
|
private int _xMax;
|
|
private int _yMax;
|
|
|
|
public RectangleMask(int xMin, int xMax, int yMin, int yMax)
|
|
{
|
|
this._xMin = xMin;
|
|
this._yMin = yMin;
|
|
this._xMax = xMax;
|
|
this._yMax = yMax;
|
|
}
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args) => x >= this._xMin + origin.X && x <= this._xMax + origin.X && y >= this._yMin + origin.Y && y <= this._yMax + origin.Y ? this.UnitApply(origin, x, y, args) : this.Fail();
|
|
}
|
|
|
|
public class Offset : GenAction
|
|
{
|
|
private int _xOffset;
|
|
private int _yOffset;
|
|
|
|
public Offset(int x, int y)
|
|
{
|
|
this._xOffset = x;
|
|
this._yOffset = y;
|
|
}
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args) => this.UnitApply(origin, x + this._xOffset, y + this._yOffset, args);
|
|
}
|
|
|
|
public class Dither : GenAction
|
|
{
|
|
private double _failureChance;
|
|
|
|
public Dither(double failureChance = 0.5) => this._failureChance = failureChance;
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args) => GenBase._random.NextDouble() >= this._failureChance ? this.UnitApply(origin, x, y, args) : this.Fail();
|
|
}
|
|
|
|
public class Flip : GenAction
|
|
{
|
|
private bool _flipX;
|
|
private bool _flipY;
|
|
|
|
public Flip(bool flipX, bool flipY)
|
|
{
|
|
this._flipX = flipX;
|
|
this._flipY = flipY;
|
|
}
|
|
|
|
public override bool Apply(Point origin, int x, int y, params object[] args)
|
|
{
|
|
if (this._flipX)
|
|
x = origin.X * 2 - x;
|
|
if (this._flipY)
|
|
y = origin.Y * 2 - y;
|
|
return this.UnitApply(origin, x, y, args);
|
|
}
|
|
}
|
|
}
|
|
}
|