/// <summary>
/// Extends a signal using the specified extension mode
/// </summary>
/// <param name="input">Signal to extend</param>
/// <param name="extensionMode">The extension mode</param>
/// <param name="beforeSize">The extension size of the left side</param>
/// <param name="afterSize">The extension size of right left side</param>
/// <returns></returns>
public static void Extend(ref Signal input, ExtensionMode extensionMode, int beforeSize, int afterSize)
{
var samples = Extend(input.Samples, extensionMode, beforeSize, afterSize);
var previousSamplingInterval = input.SamplingInterval;
input.CustomPlot = new[] { input.Start, input.Finish };
input.Start -= input.SamplingInterval * beforeSize;
input.Finish += input.SamplingInterval * afterSize;
input.Samples = samples;
input.SamplingInterval = previousSamplingInterval;
}
public void ShiftMode()
{
EPMode = (ExtensionMode)(((int)EPMode + 1) % ExtendedPlatformPlacement.extensionModes.Length);
}
private bool CheckTrackExtensibility(Item item, Player player, ExtensionMode mode, ref int targetX, ref int targetY)
{
EPPlayer modPlayer = player.GetModPlayer <EPPlayer>();
if (Main.tile[targetX, targetY].active())
{
int targetTileID = item.createTile;
int x = targetX;
int y = targetY;
Tile startTile = Framing.GetTileSafely(targetX, targetY);
Tile prevTile = null;
int reach = 0;
if (startTile.type != TileID.MinecartTrack)
{
return(false);
}
TileObjectData tileData = TileObjectData.GetTileData(targetTileID, item.placeStyle);
Tile nextTile = Framing.GetTileSafely(x, y);
while (nextTile.active() && nextTile.type == TileID.MinecartTrack)
{
prevTile = nextTile;
if (modPlayer.EPMode == ExtensionMode.Horizontal || modPlayer.EPMode == ExtensionMode.Auto)
{
x += player.direction;
}
else if (modPlayer.EPMode == ExtensionMode.Upward)
{
x += player.direction;
y -= 1;
}
else if (modPlayer.EPMode == ExtensionMode.Downward)
{
x += player.direction;
if (reach != 0 || startTile.slope() != 0)
{
y += 1;
}
}
else
{
return(false);
}
nextTile = Framing.GetTileSafely(x, y);
if (nextTile == null || x < 0 || y < 0 || x >= Main.mapMaxX || y >= Main.mapMaxY)
{
return(false);
}
++reach;
}
if (!nextTile.active())
{
targetX = x;
targetY = y;
return(true);
}
}
return(false);
}
private bool CheckExtensibility(Item item, Player player, ExtensionMode mode, ref int targetX, ref int targetY)
{
EPPlayer modPlayer = player.GetModPlayer <EPPlayer>();
if (Main.tile[targetX, targetY].active())
{
int targetTileID = item.createTile;
int x = targetX;
int y = targetY;
Tile startTile = Framing.GetTileSafely(targetX, targetY);
Tile prevTile = null;
int reach = 0;
TileObjectData tileData = TileObjectData.GetTileData(targetTileID, item.placeStyle);
Tile nextTile = Framing.GetTileSafely(x, y);
while (nextTile.active() && IsPlatform(nextTile.type) &&
(reach <= 1 || nextTile.HasSameSlope(prevTile)) && !nextTile.lava())
{
prevTile = nextTile;
if (modPlayer.EPMode == ExtensionMode.Horizontal || (modPlayer.EPMode == ExtensionMode.Auto && startTile.slope() == 0))
{
x += player.direction;
}
else if ((modPlayer.EPMode == ExtensionMode.Upward && startTile.slope() != (player.direction == 1 ? 1 : 2)) ||
(modPlayer.EPMode == ExtensionMode.Auto && startTile.slope() == (player.direction == 1 ? 2 : 1)))
{
x += player.direction;
y -= 1;
}
else if ((modPlayer.EPMode == ExtensionMode.Downward && startTile.slope() != (player.direction == 1 ? 2 : 1)) ||
(modPlayer.EPMode == ExtensionMode.Auto && startTile.slope() == (player.direction == 1 ? 1 : 2)))
{
x += player.direction;
if (reach != 0 || startTile.slope() != 0)
{
y += 1;
}
}
else
{
return(false);
}
nextTile = Framing.GetTileSafely(x, y);
if (nextTile == null || x < 0 || y < 0 || x >= Main.mapMaxX || y >= Main.mapMaxY)
{
return(false);
}
++reach;
}
if (!nextTile.active())
{
targetX = x;
targetY = y;
return(true);
}
}
return(false);
//if (Main.tileRope[inventory[selectedItem].createTile] && canUse && Main.tile[tileTargetX, tileTargetY].active() && Main.tileRope[Main.tile[tileTargetX, tileTargetY].type])
//{
// int num = tileTargetY;
// int num2 = tileTargetX;
// _ = inventory[selectedItem].createTile;
// while (Main.tile[num2, num].active() && Main.tileRope[Main.tile[num2, num].type] && num < Main.maxTilesX - 5 && Main.tile[num2, num + 2] != null && !Main.tile[num2, num + 1].lava())
// {
// num++;
// if (Main.tile[num2, num] == null)
// {
// canUse = false;
// num = tileTargetY;
// break;
// }
// }
// if (!Main.tile[num2, num].active())
// tileTargetY = num;
//}
//return canUse;
}
/// <summary>
/// Extends an array using the specified extension mode
/// </summary>
/// <param name="input">Array to extend</param>
/// <param name="extensionMode">The extension mode</param>
/// <param name="extensionSize">The extension size of the left and right sides (each one)</param>
/// <returns></returns>
public static double[] Extend(double[] input, ExtensionMode extensionMode, int extensionSize)
{
return(Extend(input, extensionMode, extensionSize, extensionSize));
}
/// <summary>
/// Extends an array using the specified extension mode
/// </summary>
/// <param name="input">Array to extend</param>
/// <param name="extensionMode">The extension mode</param>
/// <param name="beforeSize">The extension size of the left side</param>
/// <param name="afterSize">The extension size of right left side</param>
/// <returns></returns>
public static double[] Extend(double[] input, ExtensionMode extensionMode, int beforeSize, int afterSize)
{
if (input.Length == 0)
{
return(MemoryPool.Pool.New <double>(beforeSize + afterSize, true));
}
var pointsHalfLength = input.Length;
while (beforeSize > input.Length || afterSize > input.Length)
{
input = Extend(input, extensionMode, pointsHalfLength);
return(input);
}
var beforeExtension = MemoryPool.Pool.New <double>(beforeSize, true);
var afterExtension = MemoryPool.Pool.New <double>(afterSize, true);
if (extensionMode != ExtensionMode.ZeroPadding)
{
if (extensionMode == ExtensionMode.SymmetricHalfPoint || extensionMode == ExtensionMode.AntisymmetricHalfPoint)
{
if (beforeSize > 0)
{
Array.Copy(input, beforeExtension, beforeSize);
Array.Reverse(beforeExtension);
}
Array.Copy(input, input.Length - afterSize, afterExtension, 0, afterSize);
Array.Reverse(afterExtension);
if (extensionMode == ExtensionMode.AntisymmetricHalfPoint)
{
if (beforeSize > 0)
{
beforeExtension = WaveMath.Multiply(beforeExtension, -1);
}
afterExtension = WaveMath.Multiply(afterExtension, -1);
}
}
else if (extensionMode == ExtensionMode.SymmetricWholePoint)
{
if (beforeSize > 0)
{
Array.Copy(input, input.Length > beforeSize ? 1 : 0, beforeExtension, 0, beforeSize);
Array.Reverse(beforeExtension);
}
Array.Copy(input, input.Length - afterSize - 1 < 0 ? 0 : input.Length - afterSize - 1, afterExtension, 0, afterSize);
Array.Reverse(afterExtension);
}
else if (extensionMode == ExtensionMode.AntisymmetricWholePoint)
{
if (beforeSize > 0)
{
beforeExtension = GetAntisymmetricWholePointBefore(input, beforeSize);
}
afterExtension = GetAntisymmetricWholePointAfter(input, afterSize);
}
else if (extensionMode == ExtensionMode.PeriodicPadding)
{
if (beforeSize > 0)
{
Array.Copy(input, input.Length - beforeSize, beforeExtension, 0, beforeSize);
}
Array.Copy(input, 0, afterExtension, 0, afterSize);
}
else if (extensionMode == ExtensionMode.SmoothPadding0)
{
if (beforeSize > 0)
{
for (var i = 0; i < beforeExtension.Length; i++)
{
beforeExtension[i] = input[0];
}
}
for (var i = 0; i < afterExtension.Length; i++)
{
afterExtension[i] = input[input.Length - 1];
}
}
else if (extensionMode == ExtensionMode.SmoothPadding1)
{
double previous;
if (beforeSize > 0)
{
var beforeDif = input[0] - input[1];
previous = input[0];
for (var i = beforeSize - 1; i >= 0; i--)
{
beforeExtension[i] = previous + beforeDif;
previous = beforeExtension[i];
}
}
var afterDif = input[input.Length - 1] - input[input.Length - 2];
previous = input[input.Length - 1];
for (var i = 0; i < afterSize; i++)
{
afterExtension[i] = previous + afterDif;
previous = afterExtension[i];
}
}
}
var newPoints = MemoryPool.Pool.New <double>(beforeSize + input.Length + afterSize);
if (beforeSize > 0)
{
beforeExtension.CopyTo(newPoints, 0);
}
input.CopyTo(newPoints, beforeSize);
afterExtension.CopyTo(newPoints, beforeSize + input.Length);
return(newPoints);
}
