private GameObject[] GetCubesForFace(GameObject[] cubes, RubiksFace face, float distance = 0.9f)
{
List <GameObject> faceCubes = new List <GameObject>();
foreach (GameObject cube in m_cubes)
{
if (face == RubiksFace.UP && cube.transform.position.y > distance)
{
faceCubes.Add(cube);
}
else if (face == RubiksFace.BOTTOM && cube.transform.position.y < -distance)
{
faceCubes.Add(cube);
}
else if (face == RubiksFace.LEFT && cube.transform.position.x < -distance)
{
faceCubes.Add(cube);
}
else if (face == RubiksFace.LEFT_OPPOSITE && cube.transform.position.x > distance)
{
faceCubes.Add(cube);
}
else if (face == RubiksFace.RIGHT && cube.transform.position.z < -distance)
{
faceCubes.Add(cube);
}
else if (face == RubiksFace.RIGHT_OPPOSITE && cube.transform.position.z > distance)
{
faceCubes.Add(cube);
}
}
return(faceCubes.ToArray());
}
public void SetHighlightMaterial(RubiksFace face, bool set, bool fromButton = false)
{
if (fromButton)
{
m_canResetHighlight = !set;
}
GameObject[] faceCubes = GetCubesForFace(m_cubes, face);
foreach (GameObject cube in faceCubes)
{
Renderer cubeRenderer = cube.GetComponent <Renderer>();
if (set)
{
if (cubeRenderer.sharedMaterial != m_highlightMaterial)
{
cubeRenderer.sharedMaterial = m_highlightMaterial;
}
}
else
{
if (cubeRenderer.sharedMaterial != m_defaultMaterial)
{
cubeRenderer.sharedMaterial = m_defaultMaterial;
}
}
}
}
private void Update()
{
if (!RubiksCubeRotation.IsRotating && !m_rubiksCubeManager.IsApplyingSequence && !m_rubiksCubeManager.IsVictoryPopupActive)
{
RubiksFace previousFace = m_faceToRotate;
bool didRaycastHit = TryRaycast();
if (m_canResetHighlight && (!didRaycastHit || previousFace != m_faceToRotate))
{
SetHighlightMaterial(previousFace, false);
}
if (didRaycastHit)
{
SetHighlightMaterial(m_faceToRotate, true);
}
if (Input.GetMouseButtonDown(0))
{
if (didRaycastHit)
{
Rotate(m_faceToRotate, FaceRotation.CLOCKWISE, m_faceGO, m_rotationSpeed, OnRotationFinished);
}
}
else if (Input.GetMouseButtonDown(1))
{
if (didRaycastHit)
{
Rotate(m_faceToRotate, FaceRotation.COUNTERCLOCKWISE, m_faceGO, m_rotationSpeed, OnRotationFinished);
}
}
}
}
private RubiksColor GetFaceColor(RubiksFace faceToRotate)
{
switch (faceToRotate)
{
case RubiksFace.LEFT:
return(m_rubiksCubeManager.LeftFaceColor);
case RubiksFace.LEFT_OPPOSITE:
return(m_rubiksCubeManager.Logic.RubiksOppositeColor[m_rubiksCubeManager.LeftFaceColor]);
case RubiksFace.RIGHT:
return(m_rubiksCubeManager.RightFaceColor);
case RubiksFace.RIGHT_OPPOSITE:
return(m_rubiksCubeManager.Logic.RubiksOppositeColor[m_rubiksCubeManager.RightFaceColor]);
case RubiksFace.UP:
return(m_rubiksCubeManager.UpFaceColor);
case RubiksFace.BOTTOM:
return(m_rubiksCubeManager.Logic.RubiksOppositeColor[m_rubiksCubeManager.UpFaceColor]);
default: return(RubiksColor.NONE);
}
}
private void RotateSidesCounterClockWise(RubiksFace toRotate)
{
RubiksFace topLinkedFace = m_rubiksData[toRotate.LinkedColorTop];
RubiksFace rightLinkedFace = m_rubiksData[toRotate.LinkedColorRight];
RubiksFace leftLinkedFace = m_rubiksData[toRotate.LinkedColorLeft];
RubiksFace bottomLinkedFace = m_rubiksData[toRotate.LinkedColorBottom];
RubiksPosition[] topLinkedPositions = GetTopLinkedPositions(toRotate.Color);
RubiksPosition[] leftLinkedPositions = GetLeftLinkedPositions(toRotate.Color);
RubiksPosition[] bottomLinkedPositions = GetBottomLinkedPositions(toRotate.Color);
RubiksPosition[] rightLinkedPositions = GetRightLinkedPositions(toRotate.Color);
RubiksColor tempTopLinkedFirstColor = topLinkedFace.GetColor(topLinkedPositions[0]);
RubiksColor tempTopLinkedSecondColor = topLinkedFace.GetColor(topLinkedPositions[1]);
RubiksColor tempTopLinkedThirdColor = topLinkedFace.GetColor(topLinkedPositions[2]);
topLinkedFace.Face[topLinkedPositions[0]] = rightLinkedFace.GetColor(rightLinkedPositions[0]);
topLinkedFace.Face[topLinkedPositions[1]] = rightLinkedFace.GetColor(rightLinkedPositions[1]);
topLinkedFace.Face[topLinkedPositions[2]] = rightLinkedFace.GetColor(rightLinkedPositions[2]);
rightLinkedFace.Face[rightLinkedPositions[0]] = bottomLinkedFace.GetColor(bottomLinkedPositions[0]);
rightLinkedFace.Face[rightLinkedPositions[1]] = bottomLinkedFace.GetColor(bottomLinkedPositions[1]);
rightLinkedFace.Face[rightLinkedPositions[2]] = bottomLinkedFace.GetColor(bottomLinkedPositions[2]);
bottomLinkedFace.Face[bottomLinkedPositions[0]] = leftLinkedFace.GetColor(leftLinkedPositions[0]);
bottomLinkedFace.Face[bottomLinkedPositions[1]] = leftLinkedFace.GetColor(leftLinkedPositions[1]);
bottomLinkedFace.Face[bottomLinkedPositions[2]] = leftLinkedFace.GetColor(leftLinkedPositions[2]);
leftLinkedFace.Face[leftLinkedPositions[0]] = tempTopLinkedFirstColor;
leftLinkedFace.Face[leftLinkedPositions[1]] = tempTopLinkedSecondColor;
leftLinkedFace.Face[leftLinkedPositions[2]] = tempTopLinkedThirdColor;
}
private void SetRubiksFaceParents(RubiksFace faceToRotate, GameObject faceGO)
{
GameObject[] faceCubes = GetCubesForFace(m_cubes, faceToRotate);
foreach (GameObject cube in faceCubes)
{
cube.transform.parent = faceGO.transform;
}
}
void Update()
{
RubiksFace face = null;
if (Input.GetKeyDown(KeyCode.F))
{
face = this.Front;
}
if (Input.GetKeyDown(KeyCode.B))
{
face = this.Back;
}
if (Input.GetKeyDown(KeyCode.R))
{
face = this.Right;
}
if (Input.GetKeyDown(KeyCode.L))
{
face = this.Left;
}
if (Input.GetKeyDown(KeyCode.U))
{
face = this.Up;
}
if (Input.GetKeyDown(KeyCode.D))
{
face = this.Down;
}
if (face != null)
{
this.Rotations.Enqueue(new Rotation()
{
Duration = 0.5f,
Face = face,
Times = 1 * (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift) ? -1 : 1)
});
}
if ((this.runningRotation == null) && (this.Rotations.Count > 0))
{
this.runningRotation = this.Rotations.Dequeue();
this.runningRotation.Begin();
}
if (this.runningRotation != null)
{
float time = Mathf.Min(1f, (Time.timeSinceLevelLoad - this.runningRotation.StartedAt) / this.runningRotation.Duration);
this.runningRotation.Face.RotateCW(time * this.runningRotation.Times);
if (time == 1f)
{
this.runningRotation = null;
}
}
}
public void RotateFaceCounterClockWise(RubiksColor faceColor)
{
RubiksFace toRotate = m_rubiksData[faceColor];
toRotate.RotateFaceCounterClockWise();
RotateSidesCounterClockWise(toRotate);
#if UNITY_EDITOR || DEVELOPMENT_BUILD
Debug.Log(this.ToString());
#endif
}
public RubiksLogic()
{
foreach (RubiksColor color in Enum.GetValues(typeof(RubiksColor)))
{
if (color == RubiksColor.NONE)
{
continue;
}
FillRubiksOppositeColor(color);
m_rubiksData[color] = new RubiksFace(color);
}
}
private Vector3 GetAxisForFace(RubiksFace faceToRotate)
{
switch (faceToRotate)
{
case RubiksFace.UP:
return(Vector3.up);
case RubiksFace.LEFT:
return(Vector3.right);
case RubiksFace.RIGHT:
return(Vector3.forward);
default: break;
}
return(new Vector3());
}
private float GetMultiplierForRotation(RubiksFace faceToRotate, FaceRotation direction)
{
float multiplier = 1.0f;
if (faceToRotate == RubiksFace.LEFT || faceToRotate == RubiksFace.RIGHT)
{
multiplier *= -1.0f;
}
switch (direction)
{
case FaceRotation.COUNTERCLOCKWISE:
multiplier *= -1.0f;
break;
default: break;
}
return(multiplier);
}
private IEnumerator RotateFace(RubiksFace faceToRotate, FaceRotation direction, GameObject faceGO, float duration = 1.0f, RotationCallback callback = null)
{
Quaternion from = faceGO.transform.localRotation;
Quaternion to = faceGO.transform.localRotation;
to *= Quaternion.Euler(GetMultiplierForRotation(faceToRotate, direction) * GetAxisForFace(faceToRotate) * NINETY_DEGREES);
float elapsed = 0.0f;
while (elapsed < duration)
{
faceGO.transform.rotation = Quaternion.Slerp(from, to, elapsed / duration);
elapsed += Time.deltaTime;
yield return(null);
}
faceGO.transform.rotation = to;
ResetRubiksFaceParents();
callback?.Invoke(GetFaceColor(faceToRotate), direction);
RubiksCubeRotation.SetRotationState(RubiksCubeRotation.RotationState.IDLE);
}
void Start()
{
this.pieces = new RubiksPiece[27];
for (int i = 0; i < this.pieces.Length; ++i)
{
GameObject piece = GameObject.Instantiate(this.PieceModel);
this.pieces[i] = piece.GetComponent <RubiksPiece>();
piece.name = "Piece" + i;
Vector3 position = new Vector3((i % 3) - 1, ((i / 3) % 3) - 1, ((i / 9) % 3) - 1);
piece.transform.position = position;
piece.transform.SetParent(this.transform, false);
}
this.Front = new RubiksFace(this, Vector3.back);
this.Back = new RubiksFace(this, Vector3.forward);
this.Right = new RubiksFace(this, Vector3.right);
this.Left = new RubiksFace(this, Vector3.left);
this.Up = new RubiksFace(this, Vector3.up);
this.Down = new RubiksFace(this, Vector3.down);
this.Invoke("Reset", 0.1f);
}
public void Rotate(RubiksFace faceToRotate, FaceRotation direction, GameObject faceGO, float rotationDuration, RotationCallback callback = null)
{
RubiksCubeRotation.SetRotationState(RubiksCubeRotation.RotationState.ROTATING);
SetRubiksFaceParents(faceToRotate, faceGO);
StartCoroutine(RotateFace(faceToRotate, direction, faceGO, rotationDuration, callback));
}
