public Tetro GetTetro(TetroType type)
{
Tetro tetro = pool.Where(t => t.GetTetroType() == type)
.FirstOrDefault();
tetro.transform.parent = null;
tetro.gameObject.SetActive(true);
return(tetro);
}
public void SetNextTetro(Tetro next)
{
if (NextTetro != null)
{
_renderer.Render(ClearTetro(NextTetro));
}
NextTetro = next;
_renderer.Render(RenderNextTetro(NextTetro));
}
private GridMutation RenderNextTetro(Tetro tetro)
{
var m = new TextWriter().WriteText(_x, _y + 2, "next:");
foreach (Block b in tetro.Blocks)
{
m.AddTarget(new DrawablePoint(b.X + _x + 2, b.Y + 4, b.ForeColor, b.Symbol, b.Debug));
}
return(m);
}
private void Start()
{
pontos = pontosAux = 0;
timer = 0;
tetro = GetComponent <Tetro>();
txtScore.text = "" + pontos;
txtLevel.text = "" + velocidadeQueda * 10;
}
// Set current tetromino and generate the next one
protected void ResetCurrentTetro()
{
_curTetro = _stage.GetNextTetro();
// Add all blocks from all tetrominoes to single List
// for faster rendering and colision detection
foreach (Block b in _curTetro.Blocks)
{
_blocks.Add(b);
}
}
private GridMutation ClearTetro(Tetro tetro)
{
var m = new GridMutation();
foreach (DrawablePoint b in tetro.Blocks)
{
m.AddSource(b.X + _x + 2, b.Y + 4);
}
return(m);
}
public Tetro SpawnRandomTetro()
{
int length = System.Enum.GetNames(typeof(TetroType)).Length;
int i = Random.Range(1, length);
TetroType type = (TetroType)i;
Tetro tetro = tetroPool.GetTetro(type);
tetro.transform.position = spawnPos.position;
tetro.gameObject.SetActive(true);
tetro.StartFalling(fallSpeed);
return(tetro);
}
public Tetro[] PreWarm()
{
pool = new Tetro[tetroDatas.Length];
for (int i = 0; i < pool.Length; i++)
{
Tetro t = Instantiate(tetroPrefab, poolPos.position, Quaternion.identity);
t.SetUp(tetroDatas[i]);
t.transform.parent = poolPos;
t.SetPool(this);
pool[i] = t;
}
return(pool);
}
/// <summary>
/// Finds the Tetro that contains the specified coordinates
/// </summary>
/// <param name="Row"></param>
/// <param name="Col"></param>
/// <returns></returns>
private Tetromino.TetroTemplate FindTetroAt(int Row, int Col)
{
Tetromino.TetroTemplate TetroOut = null;
foreach (Tetromino.TetroTemplate Tetro in Tetros)
{
if (Tetro.ContainsCoord(Row, Col))
{
TetroOut = Tetro;
break;
}
}
return(TetroOut);
}
/// <summary>
/// Gets the corresponding Tetromino for a specific coordinate
/// </summary>
/// <param name="Row"></param>
/// <param name="Col"></param>
/// <returns></returns>
public Tetromino GetTetroAt(int Row, int Col)
{
Tetromino foundTetro = null;
foreach (Tetromino Tetro in Tetrominos)
{
if (Tetro.ContainsCellAt(Row, Col))
{
foundTetro = Tetro;
break;
}
}
return(foundTetro);
}
public void ProximaPeca()
{
instanciaPeca = Instantiate(criapecas[proxPeca], this.transform.position, Quaternion.identity);
tetroScript = instanciaPeca.GetComponentInParent<Tetro>();
proxPeca = Random.Range(0, 7);
for (int i = 0; i < mostraPecas.Count; i++)
{
mostraPecas[i].SetActive(false);
}
mostraPecas[proxPeca].SetActive(true);
}
public bool AcimaGrade(Tetro pecaTetro)
{
for (int x = 0; x < largura; x++)
{
foreach (Transform quadrado in pecaTetro.transform)
{
Vector2 posicao = Arredonda(quadrado.position);
if (posicao.y > altura - 1)
{
return(true);
}
}
}
return(false);
}
public Tetro GetNextTetro()
{
// If new game generate 'next' before setting 'current' tetromino
if (_nextTetro == null)
{
_nextTetro = GenerateRandomTetro();
}
var curTetro = _nextTetro;
_nextTetro = GenerateRandomTetro();
// Update Scoreboard
Scoreboard.SetNextTetro(_nextTetro);
return(curTetro);
}
public void Load(SavableData savableData)
{
_renderer.Clear();
_playfield.RowRemoved += RowRemovedHandler;
var currTetro = Tetro.CreateTetro(savableData.CurrentTetro, _playfield);
var nextTetro = Tetro.CreateTetro(savableData.NextTetro, _playfield);
_nextTetro = nextTetro;
// Load scoreboard
Scoreboard.IncrementScore(savableData.Score);
Scoreboard.SetNextTetro(nextTetro);
Scoreboard.RenderScore();
// Load blocks
_playfield.SetBlocks(savableData.Blocks.Concat(currTetro.Blocks));
_playfield.SetCurrentTetro(currTetro);
_playfield.Start(_settings.Speed);
Thread.Sleep(300);
}
public void atualizaGrade(Tetro pecaTetris)
{
/*
*
* A lógica aqui é a seguinte, toda vez que é realizado um movimento na peça, esse metodo é chamado quando o movimento é válido
*
* Caso o movimento não seja válido, persevera os valores da última chamada
*
*/
// limpa a grade referente ao bloco que está caindo
for (int y = 0; y < altura; y++)
{
for (int x = 0; x < largura; x++)
{
if (grade[x, y] != null)
{
// Verifica se não é a peça que está sendo usada agora
if (grade[x, y].parent == pecaTetris.transform)
{
grade[x, y] = null;
}
}
}
}
// Esse loop passa por cada quadradinho dentro da peça de tetris
foreach (Transform quadradinhoPeca in pecaTetris.transform)
{
Vector2 posicao = Arredonda(quadradinhoPeca.position);
if ((int)posicao.y < altura)
{
grade[(int)posicao.x, (int)posicao.y] = quadradinhoPeca;
}
}
}
// Generates a random tetro
public Tetro GenerateRandomTetro()
{
TetroTypes type = (TetroTypes)_randomizer.Next(7);
return(Tetro.CreateTetro(type, _playfield));
}
public void ReturnTetro(Tetro tetro)
{
tetro.transform.SetParent(poolPos);
tetro.transform.localPosition = Vector3.zero;
}
public void SetCurrentTetro(Tetro tetro) => _curTetro = tetro;
