private void MouseUp(SquareModel s)
{
if (s.Id == hitPosition)
{
score += 1;
}
}
private static Square InstanciateSquare(GameObject prefab, SquareModel model, Vector2 interval, Transform transform)
{
var gameObject = Instantiate(prefab, Vector2.Scale(interval, model).X0Y(), Quaternion.identity, transform);
var square = gameObject.GetComponent <Square>();
square.Model = model;
return(square);
}
private bool MovePlayer(SquareModel position, bool killing)
{
board.UpdateState(position, SquareState.SquareStates.Selected);
board.UpdateStatesExcept(new [] { position });
playerMover.MoveTo(GetSquarePosition(position), UpdateStates);
return(boardModel.IsGoal(playerModel.CurrentSquare.Value));
}
public static SquareModel Rotate(this SquareModel squareModel, SquareModel rotation)
{
var vector = (Vector2)rotation;
float sin = vector.normalized.y;
float cos = vector.normalized.x;
return(new SquareModel(Mathf.RoundToInt(cos * squareModel.X - sin * squareModel.Y),
Mathf.RoundToInt(sin * squareModel.X + cos * squareModel.Y)));
}
public void UpdateState(SquareModel squareModel, SquareState.SquareStates state)
{
Square square;
if (TryGetSquare(squareModel, out square))
{
UpdateState(square, state);
}
}
/// <summary>
/// Comprueba si la pieza se puede mover a una fila / columna
/// </summary>
internal override bool CanMoveTo(SquareModel board, int fromRow, int fromColumn, int toRow, int toColumn)
{
// Comprueba si puede mover
if (IsDiagonalMovement(fromRow, fromColumn, toRow, toColumn, false))
{
return(board.IsPathEmpty(fromRow, fromColumn, toRow, toColumn) && board.IsLegalMoveTo(this, toRow, toColumn));
}
// Devuelve el valor que indica si puede mover
return(false);
}
public Vector3 GetSquarePosition(SquareModel model)
{
var square = GetSquare(model);
if (square != null)
{
return(square.Position().X0Y());
}
return(Vector3.zero);
}
public static bool BallToSquare(SquareModel door, BallModel fridge)
{
bool result = false;
if (fridge.Diameter < door.Height && fridge.Diameter < door.Width)
{
result = true;
}
return(result);
}
/// <summary>
/// Comprueba si la pieza se puede mover a una fila / columna
/// </summary>
internal override bool CanMoveTo(SquareModel board, int fromRow, int fromColumn, int toRow, int toColumn)
{
// Comprueba si es un movimiento horizontal / diagonal
if (IsVerticalHorizontalMovement(fromRow, fromColumn, toRow, toColumn, false) ||
IsDiagonalMovement(fromRow, fromColumn, toRow, toColumn, false))
{
return(board.IsPathEmpty(fromRow, fromColumn, toRow, toColumn) && board.IsLegalMoveTo(this, toRow, toColumn));
}
// Si ha llegado hasta aquí es porque el movimiento no era legal
return(false);
}
public bool TryGetSquarePosition(SquareModel model, out Vector2 position)
{
Square square;
if (TryGetSquare(model, out square))
{
position = square.Position();
return(true);
}
position = Vector2.zero;
return(false);
}
public UfStrategy Create(UnionFindType type, SquareModel[,] matrix)
{
switch (type)
{
case UnionFindType.QuickFind:
return new QuickFindStrategy(matrix);
case UnionFindType.QuickUnion:
return new QuickUnionStrategy(matrix);
case UnionFindType.WeightenedUnion:
return new WeightenedUnionStrategy(matrix);
default:
return new QuickFindStrategy(matrix);
}
}
/// <summary>
/// Comprueba si la pieza se puede mover a una fila / columna
/// </summary>
internal override bool CanMoveTo(SquareModel board, int fromRow, int fromColumn, int toRow, int toColumn)
{
int rowDifference = Math.Abs(fromRow - toRow);
int columnDifference = Math.Abs(fromColumn - toColumn);
// Puede moverse si se desplaza dos celdas en una dirección y una en otra
if ((rowDifference == 2 && columnDifference == 1) ||
(rowDifference == 1 && columnDifference == 2))
{
return(board.IsLegalMoveTo(this, toRow, toColumn));
}
// Devuelve el valor que indica que no se puede
return(false);
}
public static bool CubeToSquare(SquareModel door, CubeModel fridge)
{
bool result = false;
double[] sortedDoor = door.SortedArr();
double[] sortedFridge = fridge.SortedArr();
if (sortedDoor[0] > sortedFridge [0] && sortedDoor[1] > sortedFridge[1])
{
result = true;
}
return(result);
}
/// <summary>
/// Convierte los movimientos
/// </summary>
private List <MovementBaseModel> ConvertMovements(BoardSetup board, List <BaseMovementModel> movements)
{
SquareModel square = new SquareModel();
// Inicializa el tablero
if (board == null)
{
square.Reset();
}
else
{
square.Reset(board);
}
// Genera los movimientos
return(new Parsers.MovementConversor(square).Convert(movements));
}
//private bool lostFlag = false;//用来判断是否输了
// Use this for initialization
void Start()
{
_model = new SquareModel();
_model.OnLost += doLost;
modifier = new ModifyCubeList(_model.list);
modifier.ScoreChanged += CalculateScore;
_fsm.addState("begin", beginState());
_fsm.addState("play", playState());
_fsm.addState("input", inputState(), "play");
//_fsm.addState("move", moveState(), "play");
_fsm.addState("arise", ariseState(), "play");
_fsm.addState("end", endState());
_fsm.init("begin");
}
public static bool CylinderToSquare(SquareModel door, CylinderModel fridge)
{
bool result = false;
if (fridge.Diameter < door.Width && fridge.Diameter < door.Height)
{
result = true;
}
else if (fridge.Diameter < door.Width && fridge.Height < door.Height)
{
result = true;
}
else if (fridge.Diameter < door.Height && fridge.Height < door.Width)
{
result = true;
}
return(result);
}
/// <summary>
/// Comprueba si la pieza se puede mover a una fila / columna
/// </summary>
internal override bool CanMoveTo(SquareModel board, int fromRow, int fromColumn, int toRow, int toColumn)
{
int rowDiference = fromRow - toRow;
int columnDiference = fromColumn - toColumn;
bool can = false;
// Comprueba si se puede mover
if (Math.Abs(columnDiference) <= 1) // sólo se puede mover como máximo una columna a la izquierda
{
// Las blancas sólo se pueden mover hacia arriba y las negras sólo se pueden mover hacia abajo
if ((Math.Sign(rowDiference) == 1 && Color == PieceColor.White) ||
(Math.Sign(rowDiference) == -1 && Color == PieceColor.Black))
{
// Se puede mover dos filas: si no se ha movido y sólo ha ido en la misma columna o es una captura in Passant
if (Math.Abs(rowDiference) == 2 && !IsMoved)
{
if (columnDiference == 0) // ... movimiento normal
{
can = board.IsPathEmpty(fromRow, fromColumn, toRow, toColumn); // ... si están vacías las celdas entre una y otra
}
}
else if (Math.Abs(rowDiference) == 1)
{
if (columnDiference == 0)
{
can = board.IsEmpty(toRow, toColumn);
}
else
{
can = board.CanCapture(this, toRow, toColumn);
}
}
}
}
// Devuelve el valor que indica si se puede mover
return(can);
}
/// <summary>
/// Convierte una variación
/// </summary>
private MovementVariationModel ConvertVariation(VariationModel variation, MovementBaseModel parent)
{
MovementVariationModel movementVariation = new MovementVariationModel(parent);
SquareModel board = Board.Clone();
// Ajusta el movimiento al color de inicio de la variación
board.Parameters.IsWhiteMove = variation.Movements[0].Turn.Type == TurnModel.TurnType.White;
// Presenta el tablero
//#if DEBUG
// System.Diagnostics.Debug.WriteLine("Board for variation:");
// System.Diagnostics.Debug.WriteLine(board.GetText());
// System.Diagnostics.Debug.WriteLine(new string('-', 80));
//#endif
// Convierte los movimientos
movementVariation.Movements.AddRange(new MovementConversor(board).Convert(variation.Movements));
// Presenta el tablero real
//#if DEBUG
// System.Diagnostics.Debug.WriteLine("Board after variation:");
// System.Diagnostics.Debug.WriteLine(Board.GetText());
// System.Diagnostics.Debug.WriteLine(new string('-', 80));
//#endif
// Devuelve la variación
return(movementVariation);
}
public IEnumerable <SquareModel> OccupiedSquares(SquareModel offset, SquareModel rotation)
{
return(occupiedRange.Select(s => s.Rotate(rotation) + offset));
}
internal MovementConversor(SquareModel board)
{
Board = board;
}
private void OnPreselected(SquareModel position)
{
board.UpdateState(position, SquareState.SquareStates.Selected);
playerMover.LookAt(GetSquarePosition(position));
}
public IActionResult SquarePayment()
{
SquareModel square = new SquareModel(iConfig);
return(View(square));
}
/// <summary>
/// Square.
/// </summary>
public Square()
{
this.model = new SquareModel();
}
public void UpdateCoordinate(int x, int y)
{
model = new SquareModel(x, y);
gameObject.name = $"{x:D2}_{y:D2}";
}
public SquareView(SquareModel squareModel)
{
InitializeComponent();
this.DataContext = squareModel;
}
private Vector3 GetSquarePosition(SquareModel squareModel)
{
return(board.GetSquarePosition(squareModel));
}
public static Quaternion LookRotation(this SquareModel squareModel)
{
return(((Vector2)squareModel).LookRotation());
}
public IEnumerable <SquareModel> OccupiedSquares(SquareModel offset)
{
return(occupiedRange.Select(s => s + offset));
}
public static void RotateTest(SquareModel model, SquareModel rotation, SquareModel expected)
{
model = model.Rotate(rotation);
Assert.AreEqual(expected, model, $"Expected: ({expected.X}, {expected.Y})\nBut was: SquareModel({model.X}, {model.Y})");
}
/// <summary> /// Comprueba si la pieza se puede mover a una fila / columna /// </summary> internal abstract bool CanMoveTo(SquareModel board, int fromRow, int fromColumn, int toRow, int toColumn);
private void InitialPlayer(SquareModel position)
{
playerMover.PositionTo(GetSquarePosition(position));
UpdateStates();
}
