void Update()
{
if (!isInputAllow)
{
Debug.Log("InputController is blocking the inputs.");
return;
}
bool mouseLeftClickDown = Input.GetMouseButtonDown(0);
bool mouseLeftClickUp = Input.GetMouseButtonUp(0);
if (mouseLeftClickDown)
{
this.initPointerPos = Input.mousePosition;
checkRaycast();
}
if (!this.cubeSelected)
{
return; // If after releases the mouse button no cube was hit by the raycast, do nothing.
}
if (mouseLeftClickUp)
{
this._direction = CheckDirection();
}
if (this._direction != Direction.Cube.None)
{
this.manager.SendCommandToCube(this.cubeSelected, this._direction); // Ask to Manager to send the cube to a new position.
this._direction = Direction.Cube.None; //Resets the direction.
}
}
public virtual void Command(Direction.Cube direction, int[][] _cubesOccup)
{
if (!this.hasInteraction)
{
return;
}
this.hasInteraction = false;
Dictionary <string, int> newPosInfo = Cubes.GetCubeNewPos(this.curPos, _cubesOccup, direction);
int[] oldMatrixPos = new int[] {
newPosInfo["y"],
newPosInfo["x"]
};
int[] newMatrixPos = new int[] {
newPosInfo["newY"],
newPosInfo["newX"]
};
manager.SwitchMatrixValue(oldMatrixPos, 0);
manager.SwitchMatrixValue(newMatrixPos, newPosInfo["cubeID"]);
CubeAction(newMatrixPos);
}
public override void Command(Direction.Cube direction, int[][] _cubesOccup)
{
if (!hasInteraction)
{
return;
}
base.Command(direction, _cubesOccup);
this.lastDirection = direction;
}
IEnumerator backToInitialPosition()
{
yield return(new WaitForSeconds(1.5f));
Direction.Cube backDirection = inverseDirection(lastDirection);
this.hasInteraction = true;
manager.SendCommandToCube(gameObject, backDirection);
this.hasInteraction = false;
hasBack = true;
}
protected void startAnimation(int[] nextPos)
{
Direction.Cube upOrDown = Direction.Cube.None;
if (nextPos[0] < this.curPos[0])
{
upOrDown = Direction.Cube.Down;
}
else
{
upOrDown = Direction.Cube.Up;
}
this.curPos = nextPos;
AnimationClip clip = CustomAnimation.setAnimationTo(gameObject, nextPos, upOrDown);
anim.AddClip(clip, clip.name);
anim.Play(clip.name);
}
public void SendCommandToCube(GameObject cube, Direction.Cube direction)
{
if (!isInputAllow)
{
return;
}
int controllersLen = cubeControllerList.Count;
for (int i = 0; i < controllersLen; i++)
{
if (cubeControllerList[i].gameObject == cube)
{
int[][] cubesOccup = setup.GetCubesOccupation();
cubeControllerList[i].Command(direction, cubesOccup);
}
}
}
public override void Command(Direction.Cube direction, int[][] _cubesOccup)
{
Dictionary <string, int> newPosInfo = Cubes.GetCubeNewPos(this.curPos, _cubesOccup, direction);
int[] oldMatrixPos = new int[] {
newPosInfo["y"],
newPosInfo["x"]
};
int[] newMatrixPos = new int[] {
newPosInfo["newY"],
newPosInfo["newX"]
};
if (_cubesOccup[newMatrixPos[0]][newMatrixPos[1]] == -1)
{
isCompleted = true;
}
base.Command(direction, _cubesOccup);
}
private Direction.Cube inverseDirection(Direction.Cube _dir)
{
Direction.Cube _inverseDirection = Direction.Cube.None;
if (_dir == Direction.Cube.Left)
{
_inverseDirection = Direction.Cube.Right;
}
else if (_dir == Direction.Cube.Right)
{
_inverseDirection = Direction.Cube.Left;
}
else if (_dir == Direction.Cube.Front)
{
_inverseDirection = Direction.Cube.Back;
}
else if (_dir == Direction.Cube.Back)
{
_inverseDirection = Direction.Cube.Front;
}
return(_inverseDirection);
}
public static int GetDirectionValue(Direction.Cube _direction)
{
var directionValue = 0;
if (_direction == Direction.Cube.Left)
{
directionValue = -1;
}
if (_direction == Direction.Cube.Right)
{
directionValue = 1;
}
if (_direction == Direction.Cube.Back)
{
directionValue = 4;
}
if (_direction == Direction.Cube.Front)
{
directionValue = -4;
}
return(directionValue);
}
public static bool CheckBoundaries(int[] currentPos, Direction.Cube _direction)
{
bool canMove = false;
if (_direction == Direction.Cube.Left)
{
canMove = currentPos[1] % 4 > 0 || (currentPos[1] - 1) == 0;
}
if (_direction == Direction.Cube.Right)
{
canMove = (currentPos[1] + 1) % 4 != 0 || currentPos[1] < 3;
}
if (_direction == Direction.Cube.Back)
{
canMove = currentPos[1] + 4 < 16;
}
if (_direction == Direction.Cube.Front)
{
canMove = currentPos[1] - 4 >= 0;
}
return(!canMove);
}
public static AnimationClip setAnimationTo(GameObject objectToAnim, int[] nextPos, Direction.Cube upOrDown)
{
// Debug.Log("animation: " + objectToAnim.name);
// Debug.Log("animation: " + nextPos[1]);
// Debug.Log("animation: " + upOrDown);
var myNextPos = Cubes.GetWorldPosition(nextPos);
// AnimationCurve curveX, curveY, curveZ;
AnimationClip clip = new AnimationClip();
clip.legacy = true;
var oldPos = objectToAnim.transform.position;
if (upOrDown == Direction.Cube.Up)
{
clip = setCustomKeyFramesToClip(clip, oldPos.x, oldPos.x, myNextPos.x, "localPosition.x");
clip = setCustomKeyFramesToClip(clip, oldPos.z, oldPos.z, myNextPos.z, "localPosition.z");
clip = setCustomKeyFramesToClip(clip, oldPos.y, myNextPos.y, myNextPos.y, "localPosition.y");
}
else
{
clip = setCustomKeyFramesToClip(clip, oldPos.x, myNextPos.x, myNextPos.x, "localPosition.x");
clip = setCustomKeyFramesToClip(clip, oldPos.z, myNextPos.z, myNextPos.z, "localPosition.z");
clip = setCustomKeyFramesToClip(clip, oldPos.y, oldPos.y, myNextPos.y, "localPosition.y");
}
AnimationEvent animEv = new AnimationEvent();
animEv.time = 2.0f;
animEv.functionName = "OnAnimationEnded";
clip.events = new AnimationEvent[] { animEv };
return(clip);
}
public override void Command(Direction.Cube direction, int[][] _cubesOccup)
{
}
public static Dictionary <string, int> GetCubeNewPos(int[] pos, int[][] cubesOccupation, Direction.Cube _direction)
{
var _value = new Dictionary <string, int> {
{ "x", pos[1] },
{ "y", pos[0] },
{ "cubeID", cubesOccupation[pos[0]][pos[1]] },
{ "newX", pos[1] },
{ "newY", pos[0] },
};
if (Cubes.CheckBoundaries(pos, _direction))
{
return(_value);
}
if (Cubes.CheckBlockOverTarget(cubesOccupation, pos))
{
return(_value);
}
int[] nextPos = (int[])pos.Clone();
var directionValue = GetDirectionValue(_direction);
if (cubesOccupation[pos[0]][pos[1] + directionValue] <= 0)
{
if (pos[0] >= 1)
{
if (cubesOccupation[pos[0] - 1][pos[1] + directionValue] > 0)
{
nextPos[1] += directionValue;
}
else if (pos[0] >= 2)
{
if (cubesOccupation[pos[0] - 2][pos[1] + directionValue] > 0)
{
nextPos[0] += -1;
nextPos[1] += directionValue;
}
}
else if (pos[0] - 1 == 0)
{
nextPos[0] += -1;
nextPos[1] += directionValue;
}
}
else if (pos[0] == 0)
{
nextPos[1] += directionValue;
}
}
else if (nextPos[0] < 3)
{
if (cubesOccupation[pos[0] + 1][pos[1] + directionValue] <= 0)
{
nextPos[1] += directionValue;
nextPos[0] += 1;
}
}
_value["newX"] = nextPos[1];
_value["newY"] = nextPos[0];
return(_value);
}
