public void CheckPileMove(int index, int nodeDirection)
{
if (MatrixLimitCalcul(index, nodeDirection))
{
indexTargetNode = index + nodeDirection;
Debug.Log("---CheckPileMove--- indexTargetNode = " + indexTargetNode + " || myIndex = " + myIndex);
switch (grid.kuboGrid[indexTargetNode].cubeLayers)
{
case CubeLayers.cubeFull:
{
Debug.Log("STUCK-PILE ");
soloPileTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
break;
case CubeLayers.cubeEmpty:
{
Debug.Log("EMPTY-PILE " + (indexTargetNode - 1));
isReadyToMove = true;
soloPileTarget = grid.kuboGrid[myIndex - 1 + nodeDirection];
Debug.Log("EMPTY-PILE-CAN-MOVE ");
if (grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeLayers == CubeLayers.cubeMoveable && MatrixLimitCalcul(myIndex, _DirectionCustom.up))
{
Debug.Log("PILE-AGAIN ");
pileNodeCubeMove = grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeOnPosition.GetComponent <_CubeMove>();
pileNodeCubeMove.CheckingPile(pileNodeCubeMove.myIndex - 1, nodeDirection);
}
isCheckingMove = false;
}
break;
case CubeLayers.cubeMoveable:
{
Debug.Log("MOVE-PILE + indexTargetNode = " + indexTargetNode + " || INDEX = " + (myIndex + nodeDirection));
CheckPileMove(indexTargetNode, nodeDirection);
}
break;
}
}
else
{
Debug.Log("MATRIX LIMIT PILE");
soloPileTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
}
public void CheckPileMove(int index, int nodeDirection)
{
if (MatrixLimitCalcul(index, nodeDirection))
{
indexTargetNode = index + nodeDirection;
switch (grid.kuboGrid[indexTargetNode].cubeLayers)
{
case CubeLayers.cubeFull:
{
soloPileTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
break;
case CubeLayers.cubeEmpty:
{
isReadyToMove = true;
soloPileTarget = grid.kuboGrid[myIndex - 1 + nodeDirection];
if (grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeLayers == CubeLayers.cubeMoveable && MatrixLimitCalcul(myIndex, _DirectionCustom.up))
{
Debug.Log("TEST1");
pileNodeCubeMove = grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeOnPosition.GetComponent <_CubeMove>();
Debug.Log("TEST 2 = " + pileNodeCubeMove);
pileNodeCubeMove.CheckingPile(pileNodeCubeMove.myIndex - 1, nodeDirection);
}
isCheckingMove = false;
}
break;
case CubeLayers.cubeMoveable:
{
CheckPileMove(indexTargetNode, nodeDirection);
}
break;
}
}
else
{
soloPileTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
}
public void CheckSoloMove(int index, int nodeDirection)
{
if (MatrixLimitCalcul(index, nodeDirection))
{
indexTargetNode = index + nodeDirection;
Debug.Log("---CheckSoloMoveELEVATOR--- | " + nodeDirection);
switch (grid.kuboGrid[indexTargetNode - 1].cubeLayers)
{
case CubeLayers.cubeFull:
{
Debug.Log("STUCKELEVATOR ");
soloMoveTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
break;
case CubeLayers.cubeEmpty:
{
Debug.Log("EMPTYELEVATOR ");
if (nodeDirection == _DirectionCustom.up)
{
Debug.Log("CAN MOVE UP");
isReadyToMove = true;
IsMovingUpDown = true;
soloMoveTarget = grid.kuboGrid[myIndex + nodeDirection - 1];
isCheckingMove = false;
}
else if (nodeDirection == _DirectionCustom.down)
{
Debug.Log("CAN MOVE DOWN");
isReadyToMove = true;
IsMovingUpDown = true;
soloMoveTarget = grid.kuboGrid[myIndex + nodeDirection - 1];
GoingDownCheck(myIndex, -nodeDirection);
}
else
{
isReadyToMove = true;
soloMoveTarget = grid.kuboGrid[myIndex + nodeDirection - 1];
if (grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeLayers == CubeLayers.cubeMoveable && MatrixLimitCalcul(myIndex, _DirectionCustom.up))
{
pileNodeCubeMove = grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeOnPosition.GetComponent <_CubeMove>();
pileNodeCubeMove.CheckingPile(pileNodeCubeMove.myIndex - 1, nodeDirection);
}
Debug.Log("EMPTY-CAN MOVE-ELEVATOR");
isCheckingMove = false;
}
}
break;
case CubeLayers.cubeMoveable:
{
pushNextNodeCubeMove = grid.kuboGrid[indexTargetNode - 1].cubeOnPosition.GetComponent <_CubeMove>();
if (nodeDirection == _DirectionCustom.up || nodeDirection == _DirectionCustom.down)
{
Debug.Log("DETECT MOVE UP / DOWN");
pushNextNodeCubeMove.soloMoveTarget = grid.kuboGrid[indexTargetNode - 1 + nodeDirection];
_DataManager.instance.StartMoving.AddListener(pushNextNodeCubeMove.MoveToTarget);
pushNextNodeCubeMove.isReadyToMove = true;
cubeMoveUpDown.Add(pushNextNodeCubeMove);
}
else
{
if (pushNextNodeCubeMove.isReadyToMove == false)
{
/*if (grid.kuboGrid[indexTargetNode + nodeDirection - 1].cubeLayers == CubeLayers.cubeEmpty && grid.kuboGrid[indexTargetNode + nodeDirection + _DirectionCustom.down - 1].cubeLayers == CubeLayers.cubeEmpty)
* {
* Debug.Log("OVER NOTHING");
* pushNextNodeCubeMove.isOverNothing = true;
* }
* else if(!MatrixLimitCalcul(indexTargetNode, nodeDirection))
* {
* Debug.Log("OUSIDE");
* pushNextNodeCubeMove.isOutside = true;
* }*/
Debug.Log("APPLY DIRECTION " + nodeDirection);
pushNextNodeCubeMove.isReadyToMove = true;
pushNextNodeCubeMove.isMovingAndSTFU = true;
pushNextNodeCubeMove.CheckingMove(indexTargetNode, nodeDirection);
}
}
CheckSoloMove(indexTargetNode, nodeDirection);
}
break;
}
}
else
{
isOutside = true;
outsideMoveTarget = outsideCoord(myIndex, -nodeDirection);
Debug.Log("MATRIX LIMIT SOLOELEVATOR");
isCheckingMove = false;
}
}
public void CheckSoloMove(int index, int nodeDirection)
{
if (MatrixLimitCalcul(index, nodeDirection))
{
indexTargetNode = index + nodeDirection;
switch (grid.kuboGrid[indexTargetNode - 1].cubeLayers)
{
case CubeLayers.cubeFull:
{
soloMoveTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
break;
case CubeLayers.cubeEmpty:
{
if (nodeDirection == _DirectionCustom.up)
{
isReadyToMove = true;
IsMovingUpDown = true;
soloMoveTarget = grid.kuboGrid[myIndex + nodeDirection - 1];
isCheckingMove = false;
}
else if (nodeDirection == _DirectionCustom.down)
{
isReadyToMove = true;
IsMovingUpDown = true;
soloMoveTarget = grid.kuboGrid[myIndex + nodeDirection - 1];
GoingDownCheck(myIndex, -nodeDirection);
}
else
{
isReadyToMove = true;
soloMoveTarget = grid.kuboGrid[myIndex + nodeDirection - 1];
if (grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeLayers == CubeLayers.cubeMoveable && MatrixLimitCalcul(myIndex, _DirectionCustom.up))
{
pileNodeCubeMove = grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeOnPosition.GetComponent <_CubeMove>();
pileNodeCubeMove.CheckingPile(pileNodeCubeMove.myIndex - 1, nodeDirection);
}
isCheckingMove = false;
}
}
break;
case CubeLayers.cubeMoveable:
{
pushNextNodeCubeMove = grid.kuboGrid[indexTargetNode - 1].cubeOnPosition.GetComponent <_CubeMove>();
if (nodeDirection == _DirectionCustom.up || nodeDirection == _DirectionCustom.down)
{
pushNextNodeCubeMove.soloMoveTarget = grid.kuboGrid[indexTargetNode - 1 + nodeDirection];
_DataManager.instance.StartMoving.AddListener(pushNextNodeCubeMove.MoveToTarget);
pushNextNodeCubeMove.isReadyToMove = true;
cubeMoveUpDown.Add(pushNextNodeCubeMove);
}
else
{
if (pushNextNodeCubeMove.isReadyToMove == false)
{
pushNextNodeCubeMove.isReadyToMove = true;
pushNextNodeCubeMove.isMovingAndSTFU = true;
pushNextNodeCubeMove.CheckingMove(indexTargetNode, nodeDirection);
}
}
CheckSoloMove(indexTargetNode, nodeDirection);
}
break;
}
}
else
{
isOutside = true;
outsideMoveTarget = outsideCoord(myIndex, -nodeDirection);
isCheckingMove = false;
}
}
public void CheckSoloMove(int index, int nodeDirection)
{
if (isMovingAndSTFU == false)
{
if (MatrixLimitCalcul(index, nodeDirection))
{
indexTargetNode = index + nodeDirection;
Debug.Log("---CheckSoloMove--- | " + nodeDirection);
switch (grid.kuboGrid[indexTargetNode - 1].cubeLayers)
{
case CubeLayers.cubeFull:
{
Debug.Log("STUCK ");
soloMoveTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
break;
case CubeLayers.cubeEmpty:
{
Debug.Log("EMPTY ");
if (grid.kuboGrid[indexTargetNode - 1 + _DirectionCustom.down].cubeLayers == CubeLayers.cubeMoveable || grid.kuboGrid[indexTargetNode - 1 + _DirectionCustom.down].cubeLayers == CubeLayers.cubeFull)
{
isReadyToMove = true;
soloMoveTarget = grid.kuboGrid[myIndex + nodeDirection - 1];
Debug.Log("TAAAAAAAREGT MOVE " + soloMoveTarget.nodeIndex + " ||MyIndex " + myIndex);
if (grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeLayers == CubeLayers.cubeMoveable && MatrixLimitCalcul(myIndex, _DirectionCustom.up))
{
pileNodeCubeMove = grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeOnPosition.GetComponent <_CubeMove>();
pileNodeCubeMove.CheckingPile(pileNodeCubeMove.myIndex - 1, nodeDirection);
}
Debug.Log("EMPTY-CAN MOVE-");
}
else
{
isReadyToMove = true;
Debug.Log("EMPTY-CANNOT MOVE-");
soloMoveTarget = grid.kuboGrid[myIndex - 1];
}
isCheckingMove = false;
}
break;
case CubeLayers.cubeMoveable:
{
Debug.Log("MOVE ");
pushNextNodeCubeMove = grid.kuboGrid[indexTargetNode - 1].cubeOnPosition.GetComponent <_CubeMove>();
if (pushNextNodeCubeMove.isReadyToMove == false)
{
pushNextNodeCubeMove.CheckingMove(indexTargetNode, nodeDirection);
}
CheckSoloMove(indexTargetNode, nodeDirection);
}
break;
}
}
else
{
Debug.Log("MATRIX LIMIT SOLO");
soloMoveTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
}
else
{
if (MatrixLimitCalcul(index, nodeDirection))
{
indexTargetNode = index + nodeDirection;
Debug.Log("---CheckSoloMove--- | " + nodeDirection + " || index : " + index);
switch (grid.kuboGrid[indexTargetNode - 1].cubeLayers)
{
case CubeLayers.cubeFull:
{
Debug.Log("STUCK ");
soloMoveTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
break;
case CubeLayers.cubeEmpty:
{
isReadyToMove = true;
soloMoveTarget = grid.kuboGrid[index + nodeDirection - 1];
Debug.Log("EMPTY " + soloMoveTarget.nodeIndex);
if (grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeLayers == CubeLayers.cubeMoveable && MatrixLimitCalcul(myIndex, _DirectionCustom.up))
{
pileNodeCubeMove = grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeOnPosition.GetComponent <_CubeMove>();
pileNodeCubeMove.CheckingPile(pileNodeCubeMove.myIndex - 1, nodeDirection);
}
Debug.Log("EMPTY-CAN MOVE-");
isCheckingMove = false;
}
break;
case CubeLayers.cubeMoveable:
{
Debug.Log("MOVE ");
pushNextNodeCubeMove = grid.kuboGrid[indexTargetNode - 1].cubeOnPosition.GetComponent <_CubeMove>();
if (pushNextNodeCubeMove.isReadyToMove == false)
{
pushNextNodeCubeMove.CheckingMove(indexTargetNode, nodeDirection);
}
CheckSoloMove(indexTargetNode, nodeDirection);
}
break;
}
}
else
{
Debug.Log("MATRIX LIMIT SOLO");
moveOutsideTargetCustomVector = outsideCoord(myIndex, -nodeDirection);
isOutside = true;
isCheckingMove = false;
}
}
}
public void CheckSoloMove(int index, int nodeDirection)
{
if (isFalling == false)
{
if (isMovingAndSTFU == false)
{
if (MatrixLimitCalcul(index, nodeDirection))
{
indexTargetNode = index + nodeDirection;
switch (grid.kuboGrid[indexTargetNode - 1].cubeLayers)
{
case CubeLayers.cubeFull:
{
soloMoveTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
break;
case CubeLayers.cubeEmpty:
{
if (grid.kuboGrid[indexTargetNode - 1 + _DirectionCustom.down].cubeLayers == CubeLayers.cubeMoveable || grid.kuboGrid[indexTargetNode - 1 + _DirectionCustom.down].cubeLayers == CubeLayers.cubeFull)
{
isReadyToMove = true;
soloMoveTarget = grid.kuboGrid[myIndex + nodeDirection - 1];
movingToPos = true;
if (grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeLayers == CubeLayers.cubeMoveable && MatrixLimitCalcul(myIndex, _DirectionCustom.up))
{
pileNodeCubeMove = grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeOnPosition.GetComponent <_CubeMove>();
pileNodeCubeMove.CheckingPile(pileNodeCubeMove.myIndex - 1, nodeDirection);
}
}
else
{
isReadyToMove = true;
soloMoveTarget = grid.kuboGrid[myIndex - 1];
}
isCheckingMove = false;
}
break;
case CubeLayers.cubeMoveable:
{
pushNextNodeCubeMove = grid.kuboGrid[indexTargetNode - 1].cubeOnPosition.GetComponent <_CubeMove>();
if (pushNextNodeCubeMove.isReadyToMove == false)
{
pushNextNodeCubeMove.CheckingMove(indexTargetNode, nodeDirection);
}
CheckSoloMove(indexTargetNode, nodeDirection);
}
break;
}
}
else
{
soloMoveTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
}
else
{
if (MatrixLimitCalcul(index, nodeDirection))
{
indexTargetNode = index + nodeDirection;
switch (grid.kuboGrid[indexTargetNode - 1].cubeLayers)
{
case CubeLayers.cubeFull:
{
soloMoveTarget = grid.kuboGrid[myIndex - 1];
isCheckingMove = false;
}
break;
case CubeLayers.cubeEmpty:
{
isReadyToMove = true;
soloMoveTarget = grid.kuboGrid[index + nodeDirection - 1];
if (grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeLayers == CubeLayers.cubeMoveable && MatrixLimitCalcul(myIndex, _DirectionCustom.up))
{
pileNodeCubeMove = grid.kuboGrid[myIndex - 1 + _DirectionCustom.up].cubeOnPosition.GetComponent <_CubeMove>();
pileNodeCubeMove.CheckingPile(pileNodeCubeMove.myIndex - 1, nodeDirection);
}
isCheckingMove = false;
}
break;
case CubeLayers.cubeMoveable:
{
pushNextNodeCubeMove = grid.kuboGrid[indexTargetNode - 1].cubeOnPosition.GetComponent <_CubeMove>();
if (pushNextNodeCubeMove.isReadyToMove == false)
{
pushNextNodeCubeMove.CheckingMove(indexTargetNode, nodeDirection);
}
CheckSoloMove(indexTargetNode, nodeDirection);
}
break;
}
}
else
{
moveOutsideTargetCustomVector = outsideCoord(myIndex, -nodeDirection);
isOutside = true;
isCheckingMove = false;
}
}
}
}