private void Unlink(LinkerObject linkerObject)
{
if (linkerObject)
{
linkerObject.CancelLink();
SRemoveRange removeRange = GetRangeFromNextToEnd(linkerObject);
for (int index = 0; index < _LinkedObjects.Count; ++index)
{
if (index == removeRange._StartIndex - 1)
{
_LinkedObjects[index].SetFocused();
}
else if (index >= removeRange._StartIndex)
{
_LinkedObjects[index].CancelLink();
}
}
if (removeRange._Count > 0)
{
_LinkedObjects.RemoveRange(removeRange._StartIndex, removeRange._Count);
}
for (int lineIndex = 0; lineIndex < _LinkedLines.Count; ++lineIndex)
{
if (lineIndex >= removeRange._StartIndex - 1)
{
_LinkedLines[lineIndex].gameObject.SetActive(false);
}
}
_LinkedLines.RemoveRange(_LinkedObjects.Count - 1, removeRange._Count);
}
}
private static bool TryAddLink(
ref List <LinkerObject> currentLinks,
SGridCoords boardSize,
LinkerObject[,] allLinkerObjects)
{
LinkerObject focusedLinker = currentLinks[currentLinks.Count - 1];
int direction = 0;
int directionCount = Enum.GetNames(typeof(EDirection)).Length;
while (direction < directionCount)
{
SGridCoords otherCoords = focusedLinker._GridCoords.GetRelativeCoords((EDirection)direction);
if (!OutOfBounds(boardSize, otherCoords))
{
LinkerObject other = allLinkerObjects[otherCoords._Column, otherCoords._Row];
if (!currentLinks.Contains(other) &&
focusedLinker.gameObject.CompareTag(other.gameObject.tag))
{
currentLinks.Add(other);
return(true);
}
}
++direction;
}
return(false);
}
private bool IsAdjacent(LinkerObject fromObj, LinkerObject toObj)
{
if (!fromObj || !toObj)
{
return(false);
}
return(fromObj._GridCoords.IsAdjacent(toObj._GridCoords));
}
private SRemoveRange GetRangeFromNextToEnd(LinkerObject linkerObject)
{
for (int index = 0; index < _LinkedObjects.Count; ++index)
{
if (_LinkedObjects[index] == linkerObject)
{
if (index < _LinkedObjects.Count - 1)
{
return(new SRemoveRange(index + 1, _LinkedObjects.Count - (index + 1)));
}
}
}
return(new SRemoveRange(0, 0));
}
public List <LinkerObject> SpawnLinkers(int spawnCount)
{
List <LinkerObject> linkerList = new List <LinkerObject>();
Vector3 spawnerPos = gameObject.transform.position;
int spawnRow = _GridCoords._Row;
for (int y = 0; y < spawnCount; ++y, ++spawnRow)
{
GameObject go = ObjectPooler.Instance.SpawnFromPool(ObjectPoolTypes.Linker);
go.transform.position = new Vector3(
spawnerPos.x,
spawnerPos.y + (Layouts._BoardTileSize.y + Layouts._BoardPadding.y) * spawnRow,
0
);
LinkerObject linkerObject = go.GetComponent <LinkerObject>();
linkerObject.Initialize(_LinkerLogic);
linkerList.Add(linkerObject);
}
return(linkerList);
}
private void RefreshLinkersTileParents()
{
for (int x = 0; x < _BoardSize._Column; ++x)
{
for (int y = _BoardSize._Row - 1; y >= 0; --y)
{
LinkerObject obj = _LinkerObjects[x, y];
if (obj)
{
int destX = obj._GridCoords._Column;
int destY = obj._GridCoords._Row;
if (!(destX == x && destY == y))
{
_LinkerObjects[destX, destY] = obj;
_LinkerObjects[x, y] = null;
obj.gameObject.transform.parent = _BoardTiles[destX, destY].gameObject.transform;
}
}
}
}
}
public static void ShuffleBoard(
SGridCoords boardSize,
ref BoardTile[,] boardTiles,
ref LinkerObject[,] linkerObjects)
{
int n = linkerObjects.Length;
while (n > 1)
{
--n;
int k = UnityEngine.Random.Range(0, n + 1);
SGridCoords posK = ArrayIndexToCoords(boardSize, k);
SGridCoords posN = ArrayIndexToCoords(boardSize, n);
LinkerObject value = linkerObjects[posK._Column, posK._Row];
linkerObjects[posK._Column, posK._Row] = linkerObjects[posN._Column, posN._Row];
linkerObjects[posK._Column, posK._Row].transform.parent = boardTiles[posK._Column, posK._Row].transform;
linkerObjects[posK._Column, posK._Row].transform.position = boardTiles[posK._Column, posK._Row].transform.position;
linkerObjects[posK._Column, posK._Row]._GridCoords = new SGridCoords(posK._Column, posK._Row);
linkerObjects[posN._Column, posN._Row] = value;
linkerObjects[posN._Column, posN._Row].transform.parent = boardTiles[posN._Column, posN._Row].transform;
linkerObjects[posN._Column, posN._Row].transform.position = boardTiles[posN._Column, posN._Row].transform.position;
linkerObjects[posN._Column, posN._Row]._GridCoords = new SGridCoords(posN._Column, posN._Row);
}
}
public bool AddLinker(LinkerObject linkerObject)
{
if (_FallLogic.IsCollapsingCollumns())
{
// ignore inputs if board hasn't settled yet
return(false);
}
else if (linkerObject == GetFocusedObject())
{
// if compares to self, do nothing
return(false);
}
else if (_LinkedObjects.Contains(linkerObject))
{
// if already exists, unlink it and all that comes after it
Unlink(linkerObject);
return(false);
}
else if (!HasActiveLink() ||
(!_LinkedObjects.Contains(linkerObject) &&
linkerObject.gameObject.CompareTag(_LinkedObjects[0].gameObject.tag) &&
IsAdjacent(_LinkedObjects[_LinkedObjects.Count - 1], linkerObject)))
{
// if new AND same type AND adjacent, successful link
if (_LinkedObjects.Count > 0)
{
_LinkedObjects[_LinkedObjects.Count - 1].SetLinked();
LinkerLine linkerLine = ObjectPooler.Instance.SpawnFromPool(ObjectPoolTypes.LinkerLine).GetComponent <LinkerLine>();
linkerLine.CenterPosition(_LinkedObjects[_LinkedObjects.Count - 1].transform.position, linkerObject.transform.position);
_LinkedLines.Add(linkerLine);
}
_LinkedObjects.Add(linkerObject);
return(true);
}
return(false);
}
private void RefillCollumns(List <SRefillData> refillDataList)
{
foreach (SRefillData refillData in refillDataList)
{
LinkerSpawner spawner = _LinkerSpawners[refillData._Column];
if (spawner)
{
List <LinkerObject> linkerObjects = spawner.SpawnLinkers(refillData._EmptySpaces);
for (int spawnIndex = 0; spawnIndex < linkerObjects.Count; ++spawnIndex)
{
LinkerObject linker = linkerObjects[spawnIndex];
SGridCoords destCoords = new SGridCoords(refillData._Column, refillData._EmptySpaces - 1 - spawnIndex);
linker._GridCoords = destCoords;
_LinkerObjects[destCoords._Column, destCoords._Row] = linker;
linker.gameObject.transform.parent = _BoardTiles[destCoords._Column, destCoords._Row].gameObject.transform;
linker.SetFalling(
_FallSpeed,
_BoardTiles[destCoords._Column, destCoords._Row].gameObject.transform.position,
destCoords
);
}
}
}
}
