public void movePiece(TetrisMoves tm, int count)
{
switch (tm)
{
case TetrisMoves.UP: moveUp(count);
break;
case TetrisMoves.DOWN: moveDown(count);
break;
case TetrisMoves.LEFT: moveLeft(count);
break;
case TetrisMoves.RIGHT: moveRight(count);
break;
case TetrisMoves.ROTATELEFT: rotateLeft(count);
break;
case TetrisMoves.ROTATERIGHT: rotateRight(count);
break;
default:
break;
}
}
private IEnumerable <TetrisMoves> MakePossibleSolutions(TetrisState state)
{
if (state.CurrentPiece == null)
{
yield break;
}
int crtPieceColumn = state.CurrentPiece.Position.Column;
for (int rotations = 0; rotations < 4; rotations++)
{
TetrisMoves solution = MakeSolution(rotations, 0, 0);
yield return(solution);
for (int leftMoves = 1; leftMoves < crtPieceColumn + 2; leftMoves++)
{
TetrisMoves solutionsLeft = MakeSolution(rotations, leftMoves, 0);
yield return(solutionsLeft);
}
for (int rightMoves = 1; rightMoves < state.Columns - crtPieceColumn; rightMoves++)
{
TetrisMoves solutionsRight = MakeSolution(rotations, 0, rightMoves);
yield return(solutionsRight);
}
}
}
public static void movePiece(List <TetrisData> points, TetrisMoves tm, int count)
{
switch (tm)
{
case TetrisMoves.UP: moveUp(points, count);
break;
case TetrisMoves.DOWN: moveDown(points, count);
break;
case TetrisMoves.LEFT: moveLeft(points, count);
break;
case TetrisMoves.RIGHT: moveRight(points, count);
break;
case TetrisMoves.ROTATELEFT: rotateLeft(points, count);
break;
case TetrisMoves.ROTATERIGHT: rotateRight(points, count);
break;
default:
break;
}
}
public TetrisShapeDataOnly projectMove(TetrisMoves tm)
{
List <TetrisData> returnval = this.CloneData();
movePiece(returnval, tm);
TetrisShapeDataOnly tsdo = new TetrisShapeDataOnly();
tsdo.points = returnval;
return(tsdo);
}
private TetrisState ComputeStateAfterMoves(TetrisState initialState, TetrisMoves moves)
{
TetrisState prevState = initialState;
TetrisState finalState = initialState;
foreach (TetrisMove move in moves.Moves)
{
finalState = ComputeStateAfterOneMove(prevState, move);
prevState = finalState;
}
return(finalState);
}
private TetrisMoves GetBestMoves(TetrisState state)
{
double maxScore = double.MinValue;
TetrisMoves bestMoves = new TetrisMoves();
foreach (TetrisMoves moves in MakePossibleSolutions(state))
{
TetrisState solutionState = ComputeStateAfterMoves(state, moves);
double score = ScoreComputer.ComputeScore(solutionState);
//Debug.WriteLine($"{moves} {score}");
if (score > maxScore)
{
bestMoves = moves;
maxScore = score;
}
}
return(bestMoves);
}
private void ExecuteSolverCommands()
{
while (true)
{
Thread.Sleep(600 - 100 * (GameState.Speed - 4));
TetrisMoves moves = Solver.Solve(GameState);
foreach (TetrisMove move in moves.Moves)
{
switch (move)
{
case TetrisMove.MoveLeft:
ExecuteCommand((state) => Engine.MovePieceLeft(GameState));
break;
case TetrisMove.MoveRight:
ExecuteCommand((state) => Engine.MovePieceRight(GameState));
break;
case TetrisMove.MoveDown:
ExecuteCommand((state) => Engine.MovePieceDown(GameState));
break;
case TetrisMove.MoveAllTheWayDown:
ExecuteCommand((state) => Engine.MovePieceAllTheWayDown(GameState));
break;
case TetrisMove.Rotate:
ExecuteCommand((state) => Engine.RotatePiece(GameState));
break;
default:
throw new Exception($"Unknown move: {move}");
}
Thread.Sleep(Math.Max(0, 150 - 30 * (GameState.Speed - 4)));
}
}
}
private TetrisMoves MakeSolution(int rotations, int leftMoves, int rightMoves)
{
TetrisMoves solution = new TetrisMoves();
for (int i = 0; i < rotations; i++)
{
solution.Moves.Add(TetrisMove.Rotate);
}
for (int i = 0; i < leftMoves; i++)
{
solution.Moves.Add(TetrisMove.MoveLeft);
}
for (int i = 0; i < rightMoves; i++)
{
solution.Moves.Add(TetrisMove.MoveRight);
}
solution.Moves.Add(TetrisMove.MoveAllTheWayDown);
return(solution);
}
public void movePiece(TetrisMoves tm)
{
movePiece(tm, 1);
}
public static void movePiece(List <TetrisData> points, TetrisMoves tm)
{
movePiece(points, tm, 1);
}
