private void AddNewPieces()
{
for (var i = 0; i < _config.GetGridWidth(); i++)
{
var missingPieces = 0;
for (var j = 0; j < _config.GetGridHeight(); j++)
{
if (_grid[i][j] == null)
{
PieceDO piece = _currentPool[_currentPool.Count - 1];
ChangePiece(piece, i, j);
_gameView.RecreatePiece(piece, ++missingPieces);
_grid[i][j] = piece;
_currentPool.Remove(piece);
}
}
}
if (_addDiamondPiece)
{
int col = Random.Range(0, _config.GetGridWidth());
int row = Random.Range(0, _config.GetGridWidth());
PieceType type = GetRandomType(_diamondValues);
ChangePiece(_grid[col][row], col, row, type);
_addDiamondPiece = false;
}
_gameView.IsDropping = true;
}
private void OnRemoveBonus(BonusType type, Action finishCallBack)
{
foreach (List <PieceDO> list in _grid)
{
PieceDO piece = list.Find(p => p.View.HasBonus && p.View.BonusType == type);
if (piece != null)
{
List <PieceDO> match = LookForMatchesToList(piece.View.Cell, piece.Type);
piece.View.RemoveBonus(() =>
{
if (finishCallBack != null)
{
finishCallBack();
}
foreach (PieceDO pieceDo in match)
{
pieceDo.Checked = false;
pieceDo.Locked = false;
pieceDo.View.Cell.IsMarked = false;
pieceDo.View.ActivateBonusBorder(false);
}
});
break;
}
}
}
private void ActivateColorBonus(PieceDO pieceDo)
{
int rndI = Random.Range(2, _config.GetGridWidth() - 2);
int rndJ = Random.Range(2, _config.GetGridHeight() - 2);
_grid[rndI][rndJ].View.Cell.ChangeType(pieceDo.Type, GetTypeSprite(pieceDo.Type), true, 3);
}
public void Initialize(PieceDO renderData)
{
GetData = renderData;
_spriteIcon.spriteName = GetData.Sprite;
GetData.View = this;
}
private void ChangePieceType(PieceDO piece, PieceType type)
{
piece.Type = type;
piece.Sprite = GetTypeSprite(piece.Type);
if (piece.View != null)
{
piece.View.Change();
}
}
private PieceDO ChangePiece(PieceDO piece, int col, int row, PieceType type = 0)
{
piece.Col = col;
piece.Row = row;
piece.Type = type == 0 ? GetRandomType(_values) : type;
piece.Sprite = GetTypeSprite(piece.Type);
piece.View.Change();
return(piece);
}
private PieceDO CreatePiece(int col, int row, PieceType type = 0)
{
var piece = new PieceDO();
piece.Col = col;
piece.Row = row;
piece.Type = type == 0 ? GetRandomType(_values) : type;
piece.Sprite = GetTypeSprite(piece.Type);
return(piece);
}
private void ActivateSuperCubeBonus()
{
List <List <int> > colorPieces = new List <List <int> >();
colorPieces.Add(new List <int>());
colorPieces.Add(new List <int>());
colorPieces.Add(new List <int>());
colorPieces.Add(new List <int>());
colorPieces.Add(new List <int>());
PieceDO piece = null;
for (int i = 0; i < _config.GetGridWidth(); i++)
{
for (int j = 0; j < _config.GetGridHeight(); j++)
{
piece = _grid[i][j];
if (piece.Type == PieceType.FRIEND_DIAMOND || piece.Type == PieceType.MAGIC_DIAMOND)
{
continue;
}
colorPieces[(int)piece.Type - 1].Add((int)piece.Type);
}
}
colorPieces.Sort((p1, p2) => p1.Count.CompareTo(p2.Count));
for (int i = 0; i < _config.GetGridWidth(); i++)
{
for (int j = 0; j < _config.GetGridHeight(); j++)
{
piece = _grid[i][j];
if (piece.Type == PieceType.FRIEND_DIAMOND || piece.Type == PieceType.MAGIC_DIAMOND)
{
continue;
}
while (colorPieces[0].Count == 0)
{
colorPieces.RemoveAt(0);
}
int len = colorPieces[0].Count;
piece.Type = (PieceType)colorPieces[0][len - 1];
piece.Sprite = GetTypeSprite(piece.Type);
piece.View.Change();
colorPieces[0].RemoveAt(len - 1);
}
}
CheckForMatches();
}
private void ResetGridState()
{
for (var i = 0; i < _config.GetGridWidth(); i++)
{
for (var j = 0; j < _config.GetGridHeight(); j++)
{
PieceDO piece = _grid[i][j];
piece.Checked = false;
piece.Locked = false;
piece.View.Cell.IsMarked = false;
}
}
}
private void ActivateBlackHoleBonus(PieceType type)
{
for (int i = 0; i < _config.GetGridWidth(); i++)
{
for (int j = 0; j < _config.GetGridHeight(); j++)
{
PieceDO piece = _grid[i][j];
if (piece.Type == type && _currentPool.IndexOf(piece) == -1)
{
_currentPool.Add(piece);
}
}
}
}
private void AddMatches()
{
for (var j = 0; j < _config.GetGridHeight(); j++)
{
for (var i = 0; i < _config.GetGridWidth(); i++)
{
PieceDO piece = _grid[i][j];
if (piece.Locked)
{
continue;
}
if (piece.Col > 0 && _grid[piece.Col - 1][piece.Row].Locked)
{
continue;
}
if (piece.Col + 1 < _config.GetGridWidth() && _grid[piece.Col + 1][piece.Row].Locked)
{
continue;
}
if (piece.Row > 0 && _grid[piece.Col][piece.Row - 1].Locked)
{
continue;
}
if (piece.Row + 1 < _config.GetGridHeight() && _grid[piece.Col][piece.Row + 1].Locked)
{
continue;
}
if (piece.Col > 0)
{
ChangePieceType(_grid[piece.Col - 1][piece.Row], piece.Type);
}
if (piece.Col + 1 < _config.GetGridWidth())
{
ChangePieceType(_grid[piece.Col + 1][piece.Row], piece.Type);
}
if (piece.Row > 0)
{
ChangePieceType(_grid[piece.Col][piece.Row - 1], piece.Type);
}
if (piece.Row + 1 < _config.GetGridHeight())
{
ChangePieceType(_grid[piece.Col][piece.Row + 1], piece.Type);
}
return;
}
}
}
public void InitializeViewData(GameRenderData data)
{
_resultsContainer.gameObject.SetActive(false);
_resultsContainer.InitializeViewData(data.OnGetToMenu);
_gridSize = data.GridSize;
_piecePool = data.GridList;
for (int i = 0; i < _gridSize.x; i++)
{
List <CellView> cells = new List <CellView>();
for (int j = 0; j < _gridSize.y; j++)
{
GameObject pieceGO = _gridPieces.gameObject.AddChild(_piecePrefab);
pieceGO.transform.localScale = Vector3.one;
PieceView piece = pieceGO.GetComponent <PieceView>();
PieceDO pieceDo = data.GridList[i][j];
if (piece != null)
{
piece.Initialize(pieceDo);
piece.transform.localPosition = new Vector3(PIECE_WIDTH * i - _offsetX, PIECE_HEIGHT * j - _offsetY);
}
GameObject cellGO = _gridCells.gameObject.AddChild(_cellPrefab);
cellGO.transform.localScale = Vector3.one;
cellGO.transform.localPosition = piece.transform.localPosition;
cellGO.name = String.Format("cell {0}/{1}", i, j);
CellView cell = cellGO.GetComponent <CellView>();
cell.Piece = piece;
cell.Initialize(data.SelectCell);
cells.Add(cell);
}
_cells.Add(cells);
}
SetNeighbors();
_piecePrefab.SetActive(false);
_cellPrefab.SetActive(false);
_currentScore = 0;
_scoreCounter = new NguiLabelCounterInt(_scoreLabel);
_scoreCounter.SetInitialCounterValue(_currentScore);
_currentDiamondScore = 0;
_diamondProgressBar.value = 0;
_addDiamondPiece = data.AddDiamondPiece;
}
private void AffectAbove(PieceDO piece)
{
var row = piece.Row + 1;
while (row < _config.GetGridHeight())
{
if (_grid[piece.Col][row] != null)
{
_grid[piece.Col][row].Row--;
_grid[piece.Col][row - 1] = _grid[piece.Col][row];
_gameView.Cells[piece.Col][row - 1].Piece = _grid[piece.Col][row - 1].View;
_grid[piece.Col][row] = null;
}
row++;
}
}
private void ActivateBombBonus(PieceDO pieceDo)
{
//reset states
ResetGridState();
List <PieceDO> bonusPool = LookForMatchesToList(pieceDo.View.Cell, pieceDo.Type);
foreach (PieceDO piece in bonusPool)
{
foreach (CellView cell in piece.View.Cell.Neighbors)
{
if (_currentPool.IndexOf(cell.Piece.GetData) == -1 && cell.Piece.GetData.Type != PieceType.FRIEND_DIAMOND && cell.Piece.GetData.Type != PieceType.MAGIC_DIAMOND)
{
_currentPool.Add(cell.Piece.GetData);
}
}
}
}
private void CheckForMatches()
{
_matches.Clear();
ResetGridState();
//1. Находим общее количество совпадений
for (var j = 0; j < _config.GetGridHeight(); j++)
{
for (var i = 0; i < _config.GetGridWidth(); i++)
{
PieceDO piece = _grid[i][j];
if (piece.Checked)
{
continue;
}
_currentPool.Clear();
LookForMatches(piece.View.Cell, piece.Type);
if (_currentPool.Count > 2)
{
_matches.Add(_currentPool.ToArray());
}
CheckBonusLive();
}
}
ResetGridState();
//2. Если совпадений < 2
if (_matches.Count < 2)
{
//3. Помечаем те ячейки, которые нельзя проверять (по вертикали, горизонтали и диагонали)
LockPieces(_matches);
//4. Начинаем снизу и ищем первую попавшуюся непомеченную ячейку, у которой соседи тоже непомеченные
//5. Изменяем тип соседних ячеек на такой же тип
AddMatches();
}
}
private void CheckBonusLive()
{
PieceDO pieceDo = _currentPool.Find(p => p.View.HasBonus);
if (pieceDo != null)
{
if (_currentPool.Count > 2)
{
_currentPool.ForEach(p => p.View.ActivateBonusBorder(true));
}
else
{
pieceDo.View.RemoveBonus(() => {
_bonusController.StartBonus(pieceDo.View.BonusType, true);
_currentPool.ForEach(p => p.View.ActivateBonusBorder(false));
});
}
}
else
{
_currentPool.ForEach(p => p.View.ActivateBonusBorder(false));
}
}
private bool OnSetBonus(BonusType type)
{
CheckForMatches();
int rndMatch = -1;
while (rndMatch == -1)
{
if (_matches.Count == 0)
{
return(false);
}
rndMatch = Random.Range(0, _matches.Count);
foreach (PieceDO pieceDo in _matches[rndMatch])
{
if (pieceDo.View.HasBonus)
{
_matches.RemoveAt(rndMatch);
rndMatch = -1;
break;
}
}
}
int rndPiece = Random.Range(0, _matches[rndMatch].Length);
foreach (PieceDO pieceDo in _matches[rndMatch])
{
pieceDo.View.ActivateBonusBorder(true);
}
PieceDO piece = _matches[rndMatch][rndPiece];
piece.View.SetBonus(type);
return(true);
}
public void RecreatePiece(PieceDO piece, int missingPieces)
{
piece.View.transform.localPosition = new Vector3(PIECE_WIDTH * piece.Col - _offsetX, PIECE_HEIGHT * missingPieces + _offsetY);
piece.View.gameObject.SetActive(true);
_cells[piece.Col][piece.Row].Piece = piece.View;
}
