/// <summary>
/// Scans for and applies reductions if specified anchor tile contains a collider.
/// </summary>
/// <remarks>
/// <para>This method searches from left-to-right from specified anchor tile to
/// find furthest tile horizontally that it can be reduced with. Once the initial
/// horizontal sequence is known this method proceeds to scan vertically for other
/// sequences of colliders that can further reduce the initial horizontal sequence.</para>
/// </remarks>
/// <param name="anchor">Index of anchor tile.</param>
/// <returns></returns>
private int Scan(TileIndex anchor)
{
ColliderInfo anchorInfo = null;
this.GetColliderInfo(ref anchorInfo, anchor);
if (anchorInfo == null)
{
return(anchor.column);
}
ColliderInfo info = null, firstInfo = null, lastInfo = null;
// Begin tracking list of collider components which will be combined.
this.ResetReducedColliderTracking();
this.TrackReducedCollider(anchorInfo.Row, anchorInfo.Column, anchorInfo.Collider);
try {
TileIndex target = anchor;
BoxBounds reducedBounds = anchorInfo.Bounds;
// Scan rightwards for colliders which can be combined with anchor.
for (int column = anchor.column + 1; column < this.system.ColumnCount; ++column)
{
if (this.markedTiles[anchor.row, column])
{
break;
}
this.GetColliderInfo(ref info, anchor.row, column);
if (!this.CanReduce(info, anchorInfo))
{
break;
}
// Can candidate collider be combined with anchor?
if (!reducedBounds.Encapsulate(info.Bounds))
{
break;
}
target.column = column;
this.TrackReducedCollider(info.Row, info.Column, info.Collider);
}
this.GetColliderInfo(ref info, target);
var prevFirstBounds = anchorInfo.Bounds;
var prevLastBounds = info.Bounds;
// Extend downwards if possible, though avoid crossing T-junctions since splitting
// a T-junction will often cause more colliders to occur in result.
for (int row = anchor.row + 1; row < this.system.RowCount; ++row)
{
this.GetColliderInfo(ref firstInfo, row, anchor.column);
this.GetColliderInfo(ref lastInfo, row, target.column);
if (firstInfo == null || lastInfo == null || !this.CanReduce(firstInfo, anchorInfo) || this.CheckForTJunction(firstInfo, lastInfo))
{
goto FinishedExtendingDownards;
}
// Does first and last tile from previous row extend downwards?
if (!prevFirstBounds.Encapsulate(firstInfo.Bounds) || !prevLastBounds.Encapsulate(lastInfo.Bounds))
{
goto FinishedExtendingDownards;
}
// No need to track collider from `lastInfo` since it will be included
// within the following loop.
this.candidateColliders.Clear();
this.candidateColliders.Add(firstInfo.Collider);
// Reduce bounds for strip.
BoxBounds stripBounds = firstInfo.Bounds;
for (int column = anchor.column + 1; column <= target.column; ++column)
{
this.GetColliderInfo(ref info, row, column);
if (!this.CanReduce(info, anchorInfo) || !stripBounds.Encapsulate(info.Bounds))
{
goto FinishedExtendingDownards;
}
this.candidateColliders.Add(info.Collider);
}
// The following should not fail, but let's just be safe!
if (!reducedBounds.Encapsulate(stripBounds))
{
Debug.LogWarning("Unable to encapsulate collider on reduce.");
goto FinishedExtendingDownards;
}
target.row = row;
// Accept and track candidate colliders!
for (int i = 0; i < this.candidateColliders.Count; ++i)
{
this.TrackReducedCollider(row, anchor.column + i, this.candidateColliders[i]);
}
prevFirstBounds = firstInfo.Bounds;
prevLastBounds = lastInfo.Bounds;
}
FinishedExtendingDownards:
;
bool hasManyColliders = (this.reducedColliderCount > 1);
bool hasOneHypotheticalCollider = (this.reducedColliderCount == 1 && this.reducedColliderComponents.Count == 0);
if (hasManyColliders || hasOneHypotheticalCollider)
{
this.Reduce(anchorInfo, reducedBounds);
}
return(target.column);
}
finally {
ColliderInfo.Despawn(anchorInfo);
ColliderInfo.Despawn(info);
ColliderInfo.Despawn(firstInfo);
ColliderInfo.Despawn(lastInfo);
}
}
/// <inheritdoc cref="this.GetColliderInfo(ref ColliderInfo, int, int)"/>
/// <param name="index">Index of tile.</param>
private void GetColliderInfo(ref ColliderInfo info, TileIndex index)
{
this.GetColliderInfo(ref info, index.row, index.column);
}