public void Rotate(RotationDirectionEnum rotation)
{
if (currentTetramino == null)
{
return;
}
var newTetramino = currentTetramino.Tetramino.GetTetraminoRotated(rotation);
var newTetraminoInfo = new TetraminoGridData(newTetramino, Vector2Int.zero);
var wallKicks = WallKicksData.Get(currentTetramino.Tetramino.Type, currentTetramino.Tetramino.CurrentRotationState, rotation);
int wallKickIndex = 0;
bool valid = false;
do
{
newTetraminoInfo.Position = currentTetramino.Position + wallKicks[wallKickIndex];
valid = ValidateTetramino(newTetraminoInfo, MinoInValidPosition);
wallKickIndex++;
}while (!valid && wallKickIndex < wallKicks.Count);
if (valid)
{
ApplyNewTetramino(newTetraminoInfo);
}
}
public static RotationStateEnum AddRotation(this RotationStateEnum state, RotationDirectionEnum rotation)
{
int length = Enum.GetValues(typeof(RotationStateEnum)).Length;
int newValue = ((int)state + (int)rotation) % length;
if (newValue < 0)
{
newValue += length;
}
return((RotationStateEnum)newValue);
}
private int[,] GetRotationMatrix(RotationDirectionEnum rotation)
{
switch (rotation)
{
case RotationDirectionEnum.Clockwise:
return(clockwiseRotationMatrix);
case RotationDirectionEnum.Counterclockwise:
return(counterClockwiseRotationMatrix);
default:
throw new InvalidOperationException();
}
}
/// <summary>
/// 选择物体
/// </summary>
/// <param name="rotationDirection"></param>
private void rotateObject(RotationDirectionEnum rotationDirection)
{
Vector3 currMousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
Vector2 currMousePos2D = new Vector2(currMousePos.x, currMousePos.y);
Collider2D jigsawCollider = null;
if (isSelect)
{
jigsawCollider = hitRC.collider;
}
else
{
RaycastHit2D currRH = Physics2D.Raycast(currMousePos2D, Vector2.zero);
if (currRH)
{
jigsawCollider = currRH.collider;
}
}
if (jigsawCollider == null)
{
return;
}
GameObject jigsawGameObj = jigsawCollider.gameObject;
if (jigsawGameObj.GetComponent <JigsawContainerCpt>() == null)
{
return;
}
Transform jigsawTransform = jigsawGameObj.transform;
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
Transform[] childTF = jigsawTransform.GetComponentsInChildren <Transform>();
if (childTF != null && childTF.Length > 0)
{
if (rotationDirection.Equals(RotationDirectionEnum.Clockwise))
{
jigsawTransform.Rotate(0, 0, -rotateObjAngleAdd * Time.deltaTime);
}
else if (rotationDirection.Equals(RotationDirectionEnum.Anticlockwise))
{
jigsawTransform.Rotate(0, 0, rotateObjAngleAdd * Time.deltaTime);
}
}
}
public Tetramino GetTetraminoRotated(RotationDirectionEnum rotation)
{
int[,] rotationMatrix = GetRotationMatrix(rotation);
var minosRelativeCoordinates = AddPivot(GetMinosCoordinates(), -Pivot);
var rotatedCoordintes = new List <Vector2>();
foreach (var coordinate in minosRelativeCoordinates)
{
float newX = rotationMatrix[0, 0] * coordinate.x + rotationMatrix[1, 0] * coordinate.y;
float newY = rotationMatrix[0, 1] * coordinate.x + rotationMatrix[1, 1] * coordinate.y;
rotatedCoordintes.Add(new Vector2(newX, newY));
}
var newMinosCoordinates = AddPivot(rotatedCoordintes, Pivot);
var newMatrix = CreateTetraminoMatrix(newMinosCoordinates);
var newRotation = CurrentRotationState.AddRotation(rotation);
return(new Tetramino(Type, newMatrix, Pivot, newRotation, Color));
}
private void Update()
{
float xAxis = Input.GetAxis("Horizontal");
float yAxis = Input.GetAxis("Vertical");
if (xAxis != 0 && !horizontalInputPreviousFrame)
{
horizontalInputPreviousFrame = true;
int x = xAxis > 0 ? 1 : -1;
InputShift(new Vector2Int(x, 0));
}
if (yAxis != 0 && !verticalInputPreviousFrame)
{
verticalInputPreviousFrame = true;
RotationDirectionEnum rotation = yAxis > 0
? RotationDirectionEnum.Clockwise
: RotationDirectionEnum.Counterclockwise;
InputRotation(rotation);
}
horizontalInputPreviousFrame = xAxis != 0;
verticalInputPreviousFrame = yAxis != 0;
}
public TetraminoRotationSignal(RotationDirectionEnum rotation)
{
Rotation = rotation;
}
private void InputRotation(RotationDirectionEnum rotation)
{
signalBus.Fire(new TetraminoRotationSignal(rotation));
}
public static List <Vector2Int> Get(TetraminoTypeEnum type, RotationStateEnum currentState, RotationDirectionEnum direction)
{
WallKicksInfo wallKicks;
switch (type)
{
case TetraminoTypeEnum.O:
return(new List <Vector2Int>()
{
new Vector2Int(0, 0)
});
case TetraminoTypeEnum.I:
wallKicks = WallKicksI[currentState];
break;
case TetraminoTypeEnum.L:
case TetraminoTypeEnum.J:
case TetraminoTypeEnum.Z:
case TetraminoTypeEnum.S:
case TetraminoTypeEnum.T:
wallKicks = WallKicksJLSTZ[currentState];
break;
default:
throw new InvalidOperationException();
}
switch (direction)
{
case RotationDirectionEnum.Clockwise:
return(wallKicks.clockwiseWallKicks);
case RotationDirectionEnum.Counterclockwise:
return(wallKicks.counterClockwiseWallKicks);
default:
throw new InvalidOperationException();
}
}
