IEnumerator ProcessRestoreToPrevState(BoardSnapshot snapshot)
{
transition = Transition.Restore;
_nextBlockNumbers.Push(_block.numbers);
float halfRestoreBoardTime = _restoreBoardTime * 0.5f;
_board.highestNumber = snapshot.highestNumber;
for (int i = 0, max = _board.tiles.Length; i < max; ++i)
{
NumberedHexaTile tile = _board.tiles[i] as NumberedHexaTile;
if (tile != null && tile.cell != null)
{
tile.cell.LeanCancel();
tile.cell.LeanScale(Vector3.zero, halfRestoreBoardTime).
setEaseInBack().
setOnComplete(() => tile.Reset());
}
}
NumberedHexaCell[] cells = _block.PopCells();
for (int i = 0, max = cells.Length; i < max; ++i)
{
NumberedHexaCell cell = cells[i];
cell.LeanCancel();
cell.LeanScale(Vector3.zero, halfRestoreBoardTime).
setEaseInBack().
setOnComplete(() => ReleaseHexaCell(cell));
}
yield return(new WaitForSeconds(halfRestoreBoardTime + 0.1f));
for (int i = 0, max = snapshot.boardNumbers.Length; i < max; ++i)
{
if (snapshot.boardNumbers[i] > 0)
{
NumberedHexaCell cell = GenerateHexaCell() as NumberedHexaCell;
cell.Setup(snapshot.boardNumbers[i]);
_board.tiles[i].SetCell(cell);
cell.LeanCancel();
cell.LeanScale(Vector3.zero, Vector3.one, halfRestoreBoardTime).
setEaseOutBack();
}
}
_block.Setup(snapshot.blockNumbers);
if (onUseItem != null)
{
onUseItem(ItemType.UNDO);
}
transition = Transition.None;
}
void OnDragging(Vector3 screenPosition)
{
if (!_interactable || !HasTouchState(State.TouchDrag))
{
return;
}
if (!_moving)
{
_moving = true;
_currentDragOffset = _dragOffset;
HideRotateMarker();
SoundManager.Instance.PlayUISoundInstance(GameConstants.FX_BLOCK_GRAP);
}
Vector3 position = _cachedMainCamera.ScreenToWorldPoint(screenPosition);
position.y += _currentDragOffset;
position.z = _cellRoot.position.z;
_cellRoot.position = position;
List <NumberedHexaTile> hoveredTiles = new List <NumberedHexaTile>();
for (int i = 0, max = _cells.Count; i < max; ++i)
{
RaycastHit2D hit = Physics2D.Raycast(
_cells[i].transform.position,
Vector3.zero,
Mathf.Infinity,
1 << GameManager.TILE_LAYER
);
if (hit.collider != null)
{
NumberedHexaTile tile = hit.collider.GetComponent <NumberedHexaTile>();
if (tile.cell == null)
{
tile.Hovered(_cells[i].number);
hoveredTiles.Add(tile);
}
}
}
for (int i = 0, max = _hoveredTiles.Count; i < max; ++i)
{
if (!hoveredTiles.Contains(_hoveredTiles[i]))
{
_hoveredTiles[i].Unhovered();
}
}
_hoveredTiles = hoveredTiles;
}
IEnumerator ProcessHammer()
{
transition = Transition.Hammer;
_board.ActiveHammerIcons(true);
yield return(new WaitForSeconds(0.1f));
NumberedHexaTile targetTile = null;
Action <Vector3> onSelectTile = screenPosition => {
RaycastHit2D hit = Physics2D.Raycast(
_cachedMainCamera.ScreenToWorldPoint(screenPosition),
Vector3.zero,
Mathf.Infinity,
1 << GameManager.TILE_LAYER
);
if (hit.collider != null)
{
HexaTile tile = hit.collider.GetComponent <HexaTile>();
if (tile.cell != null)
{
targetTile = tile as NumberedHexaTile;
}
}
};
SingleTouchManager.instance.onUntouched += onSelectTile;
while (targetTile == null)
{
yield return(new WaitForEndOfFrame());
}
_board.ActiveHammerIcons(false);
if (onUseItem != null)
{
onUseItem(ItemType.BREAK);
}
NumberedHexaCell cell = targetTile.cell as NumberedHexaCell;
cell.gameObject.LeanScale(Vector3.zero, _destroyCellTime)
.setEaseInBack();
SoundManager.Instance.PlayUISoundInstance(GameConstants.FX_USE_HAMMER);
yield return(new WaitForSeconds(_destroyCellTime));
targetTile.Reset();
transition = Transition.None;
}
public void ActiveHammerIcons(bool active)
{
for (int i = 0, max = tiles.Length; i < max; ++i)
{
NumberedHexaTile tile = tiles[i] as NumberedHexaTile;
if (tile != null)
{
tile.ActivateHammer(active);
}
}
}
Stack <CombineInfo> GetCombineTree(NumberedHexaTile seed, NumberedHexaTile[] ignoreTiles)
{
Stack <CombineInfo> linkedTiles = new Stack <CombineInfo>();
if (seed != null && seed.hasCell)
{
CombineInfo seedInfo = new CombineInfo(seed, 0);
linkedTiles.Push(seedInfo);
BuildCombineTree(seedInfo, ignoreTiles, ref linkedTiles);
}
return(linkedTiles);
}
int GetCurrentHighestNumberOnBoard()
{
int highestNumber = GameConstants.LOWEST_CELL_NUMBER;
for (int i = 0, max = tiles.Length; i < max; ++i)
{
NumberedHexaTile tile = tiles[i] as NumberedHexaTile;
if (tile != null && tile.number > highestNumber)
{
highestNumber = tile.number;
}
}
return(highestNumber);
}
public void Clear()
{
Debug.Assert(tiles != null);
for (int i = 0, max = tiles.Length; i < max; ++i)
{
NumberedHexaTile tile = tiles[i] as NumberedHexaTile;
if (tile != null)
{
tile.Reset();
}
}
_highestNumber = GameConstants.LOWEST_CELL_NUMBER;
_combineEffectBuffer.Withdraw();
_explodeEffectBuffer.Withdraw();
}
IEnumerator CombineTypeA(Stack <CombineInfo> linkedTileInfos)
{
HexaTile seed = linkedTileInfos.ToArray()[linkedTileInfos.Count - 1].tile;
Vector3 to = seed.transform.position + CELL_MOVE_OFFSET;
while (linkedTileInfos.Count > 1)
{
NumberedHexaTile linkedTile = linkedTileInfos.Pop().tile;
HexaCell cell = linkedTile.cell;
Vector3 from = cell.transform.position + CELL_MOVE_OFFSET;
cell.LeanMove(from, to, _cellCombineDuration).
setEaseInBack().
setOnComplete(() => linkedTile.Reset());
}
SoundManager.Instance.PlayUISoundInstance(GameConstants.FX_CELL_COMBINING);
yield return(new WaitForSeconds(_cellCombineDuration));
}
void BuildCombineTree(CombineInfo seedInfo, NumberedHexaTile[] ignoreTiles, ref Stack <CombineInfo> stack)
{
HexaTile[] neighbors = seedInfo.tile.neighbors;
for (int i = 0, max = neighbors.Length; i < max; ++i)
{
NumberedHexaTile neighbor = neighbors[i] as NumberedHexaTile;
if (neighbor != null &&
neighbor.hasCell &&
neighbor.number == seedInfo.tile.number &&
Array.TrueForAll(stack.ToArray(), st => st.tile != neighbor) &&
Array.TrueForAll(ignoreTiles, it => it.number != neighbor.number))
{
CombineInfo neighborInfo = new CombineInfo(neighbor, seedInfo.depth + 1);
stack.Push(neighborInfo);
BuildCombineTree(neighborInfo, ignoreTiles, ref stack);
}
}
}
public IEnumerator Explode(HexaTile seed, int radius, params int[] ignoreNumbers)
{
NumberedHexaTile[] targetTiles = FindExplodeTiles(seed, Mathf.Max(0, radius - 1), ignoreNumbers);
for (int i = 0, max = targetTiles.Length; i < max; ++i)
{
NumberedHexaTile targetTile = targetTiles[i];
targetTile.Explode(0.5f);
ParticleSystem explodeEffect = _explodeEffectBuffer.Pop();
explodeEffect.transform.position =
targetTile.transform.position + Vector3.back * 0.15f;
explodeEffect.Play();
}
yield return(new WaitForSeconds(0.5f));
SoundManager.Instance.PlayUISoundInstance(GameConstants.FX_CELL_EXPLODE);
yield return(new WaitForSeconds(0.2f));
}
NumberedHexaTile[] FindExplodeTiles(HexaTile seed, int depth, params int[] ignoreNumbers)
{
if (seed == null)
{
return(new NumberedHexaTile[0]);
}
HexaTile[] neighbors = seed.neighbors;
List <NumberedHexaTile> tiles = new List <NumberedHexaTile>();
if (depth > 0)
{
for (int i = 0, max = neighbors.Length; i < max; ++i)
{
tiles.AddRange(FindExplodeTiles(neighbors[i], depth - 1, ignoreNumbers));
}
}
NumberedHexaTile tile = seed as NumberedHexaTile;
if (tile != null &&
!tiles.Contains(tile) &&
Array.TrueForAll(ignoreNumbers, n => n != tile.number))
{
tiles.Add(tile);
}
for (int i = 0, max = neighbors.Length; i < max; ++i)
{
NumberedHexaTile neighbor = neighbors[i] as NumberedHexaTile;
if (neighbor != null &&
!tiles.Contains(neighbor) &&
Array.TrueForAll(ignoreNumbers, n => n != neighbor.number))
{
tiles.Add(neighbor);
}
}
return(tiles.ToArray());
}
IEnumerator CombineTypeC(Stack <CombineInfo> linkedTileInfos)
{
int maxDepth = 0;
CombineInfo[] listInfos = linkedTileInfos.ToArray();
for (int i = 0, max = listInfos.Length; i < max; ++i)
{
if (listInfos[i].depth > maxDepth)
{
maxDepth = listInfos[i].depth;
}
}
float durationPerDepth = _cellCombineDuration / maxDepth;
while (linkedTileInfos.Count > 1)
{
CombineInfo info = linkedTileInfos.Pop();
NumberedHexaTile linkedTile = info.tile;
NumberedHexaTile targetTile = Array.Find(
linkedTileInfos.ToArray(),
ci => ci.tile.IsNeighbor(linkedTile)).tile;
HexaCell cell = linkedTile.cell;
Vector3 from = cell.transform.position + CELL_MOVE_OFFSET;
Vector3 to = targetTile.transform.position + CELL_MOVE_OFFSET;
cell.LeanMove(from, to, durationPerDepth).
setEaseInBack().
setDelay((maxDepth - info.depth) * durationPerDepth).
setOnComplete(() => linkedTile.Reset());
}
for (int i = 0; i < maxDepth; ++i)
{
yield return(new WaitForSeconds(durationPerDepth));
SoundManager.Instance.PlayUISoundInstance(GameConstants.FX_CELL_COMBINING);
}
}
IEnumerator CombineTypeB(Stack <CombineInfo> linkedTileInfos)
{
float durationPerCell = _cellCombineDuration / linkedTileInfos.Count;
while (linkedTileInfos.Count > 1)
{
NumberedHexaTile linkedTile = linkedTileInfos.Pop().tile;
NumberedHexaTile targetTile = Array.Find(
linkedTileInfos.ToArray(),
ci => ci.tile.IsNeighbor(linkedTile)).tile;
HexaCell cell = linkedTile.cell;
Vector3 from = cell.transform.position + CELL_MOVE_OFFSET;
Vector3 to = targetTile.transform.position + CELL_MOVE_OFFSET;
cell.LeanMove(from, to, durationPerCell).
setEaseInBack().
setOnComplete(() => {
SoundManager.Instance.PlayUISoundInstance(GameConstants.FX_CELL_COMBINING);
linkedTile.Reset();
});
yield return(new WaitForSeconds(durationPerCell));
}
}
IEnumerator ProcessCombineCell(NumberedHexaTile seed, NumberedHexaTile[] ignoreTiles)
{
if (seed == null || !seed.hasCell)
{
yield break;
}
Stack <CombineInfo> linkedTiles = GetCombineTree(seed, ignoreTiles);
if (linkedTiles.Count < _minCombineCellSize)
{
yield break;
}
_lastCombinedNumber = seed.number;
_lastCombinedPosition = seed.transform.position;
_score += (int)Mathf.Pow(2, seed.number) * linkedTiles.Count;
Combine combine = _combines[_combineType];
yield return(combine(linkedTiles));
if (onCombineCells != null)
{
onCombineCells(_lastCombinedNumber, linkedTiles.Count, _combineCount);
}
if (_combineCount > 0)
{
int index = Mathf.Min(_combineCount, GameConstants.FX_COMBO.Length) - 1;
SoundManager.Instance.PlayUISoundInstance(GameConstants.FX_COMBO[index]);
}
seed.cell.LeanScale(Vector3.zero, _cellCombineInterval * 0.5f).
setEaseInBack();
yield return(new WaitForSeconds(_cellCombineInterval * 0.5f));
CombineEffect combineEffect = _combineEffectBuffer.Pop();
combineEffect.transform.position = seed.transform.position + Vector3.back * 0.1f;
combineEffect.SetColor(GameManager.instance.theme.GetCellSprite(seed.number).color);
seed.Increase();
seed.cell.LeanScale(Vector3.one, _cellCombineInterval * 0.5f).
setEaseOutBack();
yield return(new WaitForSeconds(_cellCombineInterval * 0.5f));
++_combineCount;
if (seed.number <= GameConstants.HIGHEST_CELL_NUMBER)
{
if (seed.number > _highestNumber)
{
_highestNumber = seed.number;
}
SoundManager.Instance.PlayUISoundInstance(
(seed.number < GameConstants.HIGHEST_CELL_NUMBER) ?
GameConstants.FX_CELL_COMBINED :
GameConstants.FX_CELL_COMBINED_LAST_NUMBER
);
yield return(ProcessCombineCell(seed, ignoreTiles));
}
else
{
SoundManager.Instance.PlayUISoundInstance(
GameConstants.FX_CELL_COMBINED_LAST_NUMBER
);
yield return(new WaitForSeconds(0.25f));
yield return(Explode(seed, 1));
if (onReachedLastNumber != null)
{
onReachedLastNumber();
}
if (_useRemoveHighestNumber)
{
_highestNumber = GetCurrentHighestNumberOnBoard();
}
}
}
public CombineInfo(NumberedHexaTile tile, int depth)
{
this.tile = tile;
this.depth = depth;
}
