private Shape(Tetrimino tetrimino, int orientation, IEnumerable <Point> body, IEnumerable <Point> head, int translationMin, int translationMax, int width, int height)
{
Tetrimino = tetrimino;
Orientation = orientation;
Body = body;
Head = head;
TranslationMin = translationMin;
TranslationMax = translationMax;
Width = width;
Height = height;
}
void Start()
{
nextPiece = getRandomPiece();
currentPiece = null;
gameArea = GetComponentInChildren <GameArea>();
tickTime = speed;
playing = true;
}
public void DropCurrentTetrimino_BlockAtBottom_LockCurrentTetrimino()
{
Tetrimino currentTetrimino = CreateTetrimino();
Point startPoint = new Point(1, 4);
_tetrisBoardOperator.NewCurrentTetrimino(currentTetrimino, startPoint);
_tetrisBoardOperator.DropCurrentTetrimino();
Assert.True(_tetrisBoardOperator.CurrentTetriminoIsLocked);
}
public void DropCurrentTetrimino_AboveBottom_BlockNotLocked()
{
Tetrimino currentTetrimino = CreateTetrimino();
Point startPoint = new Point(3, 2);
_tetrisBoardOperator.NewCurrentTetrimino(currentTetrimino, startPoint);
_tetrisBoardOperator.DropCurrentTetrimino();
Assert.False(_tetrisBoardOperator.CurrentTetriminoIsLocked);
}
public void SetTetrimino(Tetrimino tetrimino)
{
GameObject copy = tetrimino.Shape.CreateTetorimino();
copy.transform.position = Vector3.zero;
copy.transform.Translate(tetrimino.TurnAxis);
copy.transform.SetParent(this.hold.transform, false);
copy.SetActive(true);
Clear();
this.holdingTetrimino = copy.GetComponent <Tetrimino>();
}
void SettingUpInGraph(Tetrimino tetrimino, Tetrion initializer)
{
Socket socket;
int x = 3, y = 7, z = 3;
for (int i = 0; i < 4; i++)
{
socket = _boardCreator.SocketLayers[y + (int)tetrimino.Pos[i].y][x + (int)tetrimino.Pos[i].x, z + (int)tetrimino.Pos[i].z];
socket.TetrisPart = initializer.Parts[i];
initializer.Parts[i].GetComponent <Part>().CurrentSocket = socket;
}
}
/// <summary>
/// Initializes the first two tetriminos and score text
/// </summary>
void Start()
{
// Generate initial tetriminos (the prefab should already be positioned).
_nextNext = Instantiate(staticTetriminoPrefab).GetComponent <Tetrimino>();
ShiftQueue();
_nextNext = Instantiate(staticTetriminoPrefab).GetComponent <Tetrimino>();
// Set up score text
pointsText.text = "0";
linesText.text = "0";
highScoreText.text = _save.HighScore.ToString();
}
public void GetProbability(Tetrimino tetrimino, int x, int y, double expectedProbability)
{
var extractor = new TetrisExtractor(_config);
var screenshot = new EmguScreenshot("Screenshots/tetris_play_2.png", DateTime.Now.Subtract(DateTime.MinValue));
var piece = new Piece(tetrimino, 0, x, y);
var probability = extractor.GetProbability(screenshot, piece);
Assert.LessOrEqual(probability, 1.0);
Assert.GreaterOrEqual(probability, 0.0);
Assert.AreEqual(expectedProbability, probability);
}
void NextTetrimino()
{
int i = Random.Range(0, m_allTetriminos.Length);
if (m_allTetriminos[i])
{
m_nextTetrimino = Instantiate(m_allTetriminos[i], m_nextTetriminoSpawnPoint.position, Quaternion.identity, m_nextTetriminoSpawnPoint);
}
else
{
Debug.Log("Invalid Tetrimino!");
}
}
public void RecognizeNextPiece(string imageKey, IScreenshot screenshot, Tetrimino nextPieceExpected)
{
_nextPiece++;
var result = _pieceExtractor.ExtractNextPieceFuzzy(screenshot);
Assert.True(result.IsAccepted(_probabilityThreshold));
Assert.AreEqual(nextPieceExpected, result.Result);
Assert.GreaterOrEqual(result.Probability, _probabilityThreshold);
Assert.LessOrEqual(result.Probability, 1.0);
_nextPieceRecognized++;
}
//Places 1s wherever needed whena piece either reaches bottom, either collides in a way that is not possible to go lower anymore
private void PlaceTetrimino(Tetrimino tetrimino)
{
for (int i1 = tetrimino.currentPosition.x, i2 = 0; i1 < tetrimino.currentPosition.x + Tetrimino.BLOCK_AREA; i1++, i2++)
{
for (int j1 = tetrimino.currentPosition.y, j2 = 0; j1 < tetrimino.currentPosition.y + Tetrimino.BLOCK_AREA; j1++, j2++)
{
if (tetrimino.ValidBlock(tetrimino.currentRotation, j2, i2) && InBounds(i1, j1))
{
mPlayfield[i1][j1] = (int)SpotState.FILLED_SPOT;
}
}
}
}
void onKeyDown()
{
if (gameArea.canOffset(currentPiece, 0, -1))
{
currentPiece.setPos(currentPiece.col, currentPiece.row - 1);
}
else
{
gameArea.join(currentPiece);
gameArea.tick(); // NL: force update of pieces
currentPiece = null;
}
}
public void SaveGridInit(Tetrimino SaveBlock)
{
foreach (Transform Block in SaveBlock.transform)
{
Vector2 tVec = Round(Block.position);
if (tVec.y < mGridHeight)
{
mGrid[(int)tVec.x, (int)tVec.y] = null;
}
}
}
private void TestKick(TestData testCase, Tetrimino testPiece, int rotation)
{
Queue <Tetrimino> queue = new Queue <Tetrimino>(new Tetrimino[] { testPiece });
SetUpArena(testCase.InputArena);
vModel.Session = new Game(vModel.Arena, testCase.SpawnPoint, queue);
StartGame();
Rotate(rotation);
SetPiece();
AssertArenaState(testCase.OutputArena, testPiece.Colour);
}
public void DropCurrentTetrimino_BlockAtBottom_DontMoveBlock()
{
Tetrimino currentTetrimino = CreateTetrimino();
Point startPoint = new Point(1, 4);
_tetrisBoardOperator.NewCurrentTetrimino(currentTetrimino, startPoint);
_tetrisBoardOperator.DropCurrentTetrimino();
Point endPoint = new Point(1, 4);
Assert.Equal(_blocks[1], _tetrisBoard.BlockAt(endPoint));
}
public void StoreShapeInGrid(Tetrimino tetrimino)
{
if (tetrimino == null)
{
return;
}
foreach (Transform child in tetrimino.transform)
{
Vector2 position = Vectorf.Round(child.position);
m_grid[(int)position.x, (int)position.y] = child;
}
}
/**
* 落下ブロックの描画
*/
void drawTetrimino(Resource res)
{
Tetrimino tetrimino = res.tetris.getTetrimino();
GameObject[] blocks = res.minoBlocks;
Tetrimino.Pattern pat = tetrimino.getPattern();
int num_blocks = 0;
int index = 0;
Vector2 offset = res.offset;
int base_x, base_y;
base_x = tetrimino.getPosX();
base_y = tetrimino.getPosY();
for (int y = 0; y < pat.h; y++)
{
for (int x = 0; x < pat.w; x++)
{
char c = pat.pat[index];
if (c == '1')
{
float posx = x + base_x + offset.x;
float posy = y + base_y + offset.y;
GameObject block = blocks[num_blocks];
block.transform.position = new Vector3(posx, posy, 0);
//blk.GetComponent<Renderer>().material.color = m_colorList[tetrimino.getColorIndex()];
int color_index = tetrimino.getColorIndex();
MeshQuad mesh = block.GetComponent <MeshQuad>();
Color[] colors = new Color[]
{
m_colorList[color_index],
m_colorList[color_index],
m_colorList[color_index],
m_colorList[color_index],
};
mesh.updateUv(m_blockUvList);
mesh.updateColor(colors);
num_blocks++;
}
index++;
}
}
}
public void OutOfBounds(GameObject tetrimino)
{
for (int x = 0; x < width; ++x)
{
foreach (GameObject cube in FindObjectOfType <Tetrimino>().cubes)
{
Vector2 v = Tetrimino.RoundVector(cube.transform.position);
if (v.y > height - 1)
{
GameOver();
}
}
}
}
public void InsertTetrimino(Tetrimino tetrimino)
{
Debug.Log("insert_tetrimino(" + tetrimino.Position.x + ", " + tetrimino.Position.y + ")");
for (var y = 0; y < tetrimino.Blocks.GetLength(0); y++)
{
for (var x = 0; x < tetrimino.Blocks.GetLength(0); x++)
{
if (tetrimino.Blocks[y, x] != null)
{
field[tetrimino.Position.y + y][tetrimino.Position.x + x] = tetrimino.Blocks[y, x];
}
}
}
}
public bool CanMoveDown(Tetrimino tetrimino)
{
for (var y = 0; y < tetrimino.Blocks.GetLength(0); y++)
{
if (tetrimino.Position.y + y - 1 <= -3)
{
return(false);
}
if (tetrimino.Position.y + y - 1 == -2)
{
if (BlockRowContainsBlock(tetrimino.Blocks, 1))
{
return(false);
}
else
{
continue;
}
}
if (tetrimino.Position.y + y - 1 == -1)
{
if (BlockRowContainsBlock(tetrimino.Blocks, 0))
{
return(false);
}
else
{
continue;
}
}
for (var x = 0; x < tetrimino.Blocks.GetLength(0); x++)
{
if (tetrimino.Position.x + x < 0 || tetrimino.Position.x + x >= width)
{
continue;
}
if (field[tetrimino.Position.y + y - 1][tetrimino.Position.x + x] != null &&
tetrimino.Blocks[y, x] != null)
{
return(false);
}
}
}
return(true);
}
public void Restart()
{
IsPaused = false;
m_scoreManager.Reset();
m_dropIntervalModded = m_dropInterval;
UpdatePauseState();
foreach (Transform child in m_spawner.transform)
{
Destroy(child.gameObject);
}
m_activeShape = m_spawner.SpawnShape();
m_gameOver = false;
m_gameOverPanel.SetActive(false);
}
public void SlamCurrentTetrimino_FromTop_MoveBlockToBottom()
{
Tetrimino currentTetrimino = CreateTetrimino();
Point startPoint = new Point(0, 1);
_tetrisBoardOperator.NewCurrentTetrimino(currentTetrimino, startPoint);
_tetrisBoardOperator.SlamCurrentTetrimino();
Point endPoint = new Point(0, 4);
Assert.Null(_tetrisBoard.BlockAt(startPoint));
Assert.Equal(_blocks[1], _tetrisBoard.BlockAt(endPoint));
}
public void Rotate(Tetrimino tetrimino, int times)
{
var piece = new Piece(tetrimino);
int orientationBefore = piece.Orientation;
for (int i = 0; i < times; i++)
{
piece.Rotate();
}
int orientationAfter = piece.Orientation;
Assert.AreEqual(orientationBefore, (orientationAfter + 4 - times) % 4);
}
public void UpdateCurrentTetrimino()
{
if (CurrentTetrimino != null)
{
Spawner.Destroy(this.CurrentTetrimino.gameObject);
}
Tetrimino newTetrimino = dispenser.CreateNext().GetComponent <Tetrimino>();
newTetrimino.transform.SetParent(this.gameObject.transform);
newTetrimino.MoveToMapPosition(TetriminoSpawnX, TetriminoSpawnY);
newTetrimino.gameObject.SetActive(true);
this.CurrentTetrimino = newTetrimino;
}
public void MoveDown(Tetrimino tetrimino)
{
tetrimino.Position += new Vector2Int(0, -1);
for (var y = 0; y < tetrimino.Blocks.GetLength(0); y++)
{
for (var x = 0; x < tetrimino.Blocks.GetLength(0); x++)
{
if (tetrimino.Blocks[y, x] != null)
{
tetrimino.Blocks[y, x].Instance.GetComponent <BlockScript>().UpdatePosition(new Vector3((tetrimino.Position.x + x) * spacing, (tetrimino.Position.y + y) * spacing), moveUpdateSpeed);
}
}
}
}
public bool IsPiling(Tetrimino tetrimino)
{
foreach (Transform blockTransform in tetrimino.transform)
{
var block = blockTransform.gameObject.GetComponent <TetriminoBlock>();
Vector3 mapPosition = Position.WorldToMap(block.transform.position);
if (mapPosition.y == 0 ||
!IsEmptyAt(mapPosition + Vector3.down))
{
return(true);
}
}
return(false);
}
// this method will check if the tetrimino piece is above the grid
//it will check an individual cube in a tetrimino to check whether the
//object has gone outside of the grid
public bool CheckIsAboveGrid(Tetrimino tetrimino)
{
for (int x = 0; x < widthOfGrid; ++x)
{
foreach (Transform mino in tetrimino.transform)
{
Vector2 pos = round(mino.position);
if (pos.y > heightGrid - 1)
{
return(true);
}
}
}
return(false);
}
public bool CheckIsAboveGrid(Tetrimino tet)
{
for (int x = 0; x < gridWidth; ++x)
{
foreach (Transform mino in tet.transform)
{
Vector2 pos = Round(mino.position);
if (pos.y > gridHeight - 1)
{
return(true);
}
}
}
return(false);
}
public bool CheckIsAboveGrid(GameObject tetrimino)
{
for (int x = 0; x < width; x++)
{
foreach (GameObject cube in FindObjectOfType <Tetrimino>().cubes)
{
Vector2 v = Tetrimino.RoundVector(cube.transform.position);
if ((int)v.y > height - 1)
{
return(true);
}
}
}
return(false);
}
public void show(Tetrimino currentPiece)
{
for (int j = 0; j < 4; ++j)
{
for (int i = 0; i < 4; ++i)
{
Block b = currentPiece.getBlock(i, j);
if (b)
{
b.transform.parent = transform;
}
}
}
currentPiece.setPos(Random.Range(0, 10 - 4), 18);
}
