public void Setup(int[] numbers)
{
Debug.Assert(tiles != null);
if (numbers == null)
{
Clear();
return;
}
for (int i = 0, max = Mathf.Min(tiles.Length, numbers.Length); i < max; ++i)
{
HexaTile tile = tiles[i];
if (tile != null)
{
NumberedHexaCell cell = null;
if (numbers[i] > 0)
{
cell = GameManager.instance.GenerateHexaCell() as NumberedHexaCell;
if (cell != null)
{
cell.Setup(numbers[i]);
}
}
tile.SetCell(cell);
}
}
_highestNumber = GetCurrentHighestNumberOnBoard();
_combineEffectBuffer.Withdraw();
_explodeEffectBuffer.Withdraw();
}
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;
}
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 override bool IsEqual(HexaCell cell)
{
NumberedHexaCell numberedCell = cell as NumberedHexaCell;
if (numberedCell == null)
{
return(false);
}
return(number == numberedCell.number);
}
public void Increase()
{
NumberedHexaCell numberedCell = cell as NumberedHexaCell;
if (numberedCell == null)
{
return;
}
numberedCell.Increase();
}
void IncreaseCellBuffer(int length)
{
if (_cellBuffer == null)
{
_cellBuffer = new Queue <HexaCell>(length);
}
for (int i = 0; i < length; ++i)
{
NumberedHexaCell cell = Instantiate(_hexaCellPrefab);
cell.gameObject.SetActive(false);
cell.transform.SetParent(transform);
_cellBuffer.Enqueue(cell);
}
}
public void Setup(int[] numbers, int rotateStep = 0)
{
Reset();
state = State.Released;
_moving = false;
_rotateStep = rotateStep;
_angle = rotateStep * GameConstants.HEXA_STEP_ANGLE;
_cellRoot.localRotation = Quaternion.Euler(0.0f, 0.0f, _angle);
float innerRadius =
GameManager.instance.board.GetTileFlatOffsetWithSpacing();
Vector3 offsetX = Vector3.left * innerRadius * (numbers.Length - 1);
for (int i = 0; i < numbers.Length; ++i)
{
NumberedHexaCell cell =
GameManager.instance.GenerateHexaCell() as NumberedHexaCell;
cell.transform.SetParent(_cellRoot);
cell.transform.localRotation = Quaternion.identity;
cell.transform.localPosition =
offsetX + Vector3.right * i * innerRadius * 2.0f;
cell.transform.localScale = Vector3.zero;
cell.LeanCancel();
cell.LeanScale(Vector3.one, CELL_SETUP_SCALE_TIME).
setEaseOutBack().
setDelay(CELL_SETUP_SCALE_INTERVAL * i);
cell.Setup(numbers[i], _rotateStep * -1);
_cells.Add(cell);
}
ShowRotateMarker();
}
void CheckBoard()
{
if (_hoveredTiles.Count == _cells.Count)
{
if (onPlaced != null)
{
onPlaced();
}
for (int i = 0, max = _hoveredTiles.Count; i < max; ++i)
{
NumberedHexaCell cell = _cells[i];
_hoveredTiles[i].SetCell(cell);
LTSeq sequence = LeanTween.sequence();
sequence.append(cell.LeanScale(CELL_PLACED_SCALE, CELL_PLACED_TIME));
sequence.append(CELL_PLACED_DELAY);
sequence.append(cell.LeanScale(Vector3.one, CELL_PLACED_TIME));
}
_cells.Clear();
SoundManager.Instance.PlayUISoundInstance(GameConstants.FX_BLOCK_DROP);
_cellRoot.position = _originPosition;
GameManager.instance.CombineCells(_hoveredTiles.ToArray(), 0.25f);
ResetHoveredTiles();
}
else
{
ReplaceToPlace();
}
}
