#32 Movement amount needed for rotating piece reduction

core/src/cz/nic/tablexia/game/games/pursuit/PursuitGame.java

@@ -130,7 +130,9 @@ public class PursuitGame extends AbstractTablexiaGame<int[][]> {
 
         dragAndRotateActorListener = new DragAndRotateActorListener(new DragAndRotateActorListener.IOnRotationFinished() {
             @Override
-            public void onRotationFinished() {
+            public void onDragAndRotationFinished() {
+                Log.info(getClass(),"DRAG AND ROTATION FINISHED");
+                dragAndRotateActorListener.setPieceAnimationDone(true);
                 setGameScore(SCORE_KEY_MOVE_COUNT, movesCounter++);
             }
         }) {

core/src/cz/nic/tablexia/game/games/pursuit/action/RotateAndMovePieceInPosition.java

@@ -12,18 +12,18 @@ import cz.nic.tablexia.util.listener.DragAndRotateActorListener;
  * Created by Václav Tarantík on 3.8.15.
  */
 public class RotateAndMovePieceInPosition extends SequenceAction {
-    public RotateAndMovePieceInPosition(PuzzlePiece draggedPiece,Point position, final DragAndRotateActorListener.IOnRotationFinished iOnRotationFinished){
+    public RotateAndMovePieceInPosition(PuzzlePiece draggedPiece,float originalRotation, Point position, final DragAndRotateActorListener.IOnRotationFinished iOnRotationFinished){
         setActor(draggedPiece);
         setTarget(draggedPiece);
         Action rotationFinishedAction = new Action() {
             @Override
             public boolean act(float delta) {
-                iOnRotationFinished.onRotationFinished();
+                iOnRotationFinished.onDragAndRotationFinished();
                 return true;
             }
         };
 
-        addAction(Actions.parallel(new RotatePieceToClosestAngle(draggedPiece),new MovePieceToPosition(draggedPiece,position)));
+        addAction(Actions.parallel(new RotatePieceToClosestAngle(draggedPiece,originalRotation),new MovePieceToPosition(draggedPiece,position)));
         addAction(rotationFinishedAction);
     }
 }

core/src/cz/nic/tablexia/game/games/pursuit/action/RotatePieceToClosestAngle.java

@@ -17,13 +17,18 @@ public class RotatePieceToClosestAngle extends SequenceAction {
         setActor(draggedPiece);
         addAction(Actions.rotateTo(ArithmeticsHelper.getClosestRightAngle(draggedPiece.getRotation()), DragAndRotateActorListener.ROTATION_ANIMATION_DURATION));
     }
+    public RotatePieceToClosestAngle(PuzzlePiece draggedPiece,float originalRotation){
+        setTarget(draggedPiece);
+        setActor(draggedPiece);
+        addAction(Actions.rotateTo(ArithmeticsHelper.getAngleInRotationDirection(originalRotation,draggedPiece.getRotation()), DragAndRotateActorListener.ROTATION_ANIMATION_DURATION));
+    }
 
-    public RotatePieceToClosestAngle(PuzzlePiece draggedPiece, final DragAndRotateActorListener.IOnRotationFinished iOnRotationFinished){
-        this(draggedPiece);
+    public RotatePieceToClosestAngle(PuzzlePiece draggedPiece, float originalRotation,final DragAndRotateActorListener.IOnRotationFinished iOnRotationFinished){
+        this(draggedPiece,originalRotation);
         Action afterAction = new Action() {
             @Override
             public boolean act(float delta) {
-                iOnRotationFinished.onRotationFinished();
+                iOnRotationFinished.onDragAndRotationFinished();
                 return true;
             }
         };

core/src/cz/nic/tablexia/game/games/pursuit/helper/ArithmeticsHelper.java

@@ -2,6 +2,7 @@ package cz.nic.tablexia.game.games.pursuit.helper;
 
 import java.util.Random;
 
+import cz.nic.tablexia.util.Log;
 import cz.nic.tablexia.util.Point;
 
 /**
@@ -18,6 +19,20 @@ public class ArithmeticsHelper {
         return recalcAngle;
     }
 
+    public static float getAngleInRotationDirection(float originalRotation, float currentAngle){
+        Log.info(ArithmeticsHelper.class,"ORIGINAL ROTATION: "+originalRotation+", currentRotation: "+currentAngle  );
+        float rotationAmount = currentAngle-originalRotation;
+        float angleModule = currentAngle % 90;
+        float nearestRightAngle;
+        float roundedAngle = currentAngle - (angleModule);
+        if(currentAngle<0){
+            nearestRightAngle = rotationAmount < -20 ? roundedAngle - 90 : roundedAngle;
+        }else{
+            nearestRightAngle = rotationAmount > 20 ? roundedAngle + 90 : roundedAngle;
+        }
+        return nearestRightAngle;
+    }
+
     public static float getClosestRightAngle(float currentAngle) {
         float angleModule = currentAngle % 90;
         float nearestRightAngle = 0;

core/src/cz/nic/tablexia/game/games/pursuit/model/Grid.java

@@ -134,6 +134,7 @@ public class Grid extends Group {
 
     public void switchPieces(PuzzlePiece draggedPiece, PuzzlePiece overlappedPiece,Action moveAction) {
         if (draggedPiece != null) {
+            Log.info(getClass(),"SWITCH PIECES");
             int draggedPieceActualPosition = draggedPiece.getActualPosition();
            cz.nic.tablexia.util.Point draggedPiecePositionInPixels = getPieceGridPositionInPixels(draggedPieceActualPosition);
 
@@ -150,7 +151,7 @@ public class Grid extends Group {
     }
 
     //returns the position of piece inside grid according to piece's actual position
-    private cz.nic.tablexia.util.Point getPieceGridPositionInPixels(int actualPositionInGrid){
+    public cz.nic.tablexia.util.Point getPieceGridPositionInPixels(int actualPositionInGrid){
         float pieceSize = getWidth() / (float) numberOfColumns;
         cz.nic.tablexia.util.Point pieceOrderNumbers = getPieceOrderNumbers(actualPositionInGrid);
 

core/src/cz/nic/tablexia/util/listener/DragAndRotateActorListener.java

 package cz.nic.tablexia.util.listener;
 
 import com.badlogic.gdx.math.Vector2;
+import com.badlogic.gdx.scenes.scene2d.Action;
 import com.badlogic.gdx.scenes.scene2d.Actor;
 import com.badlogic.gdx.scenes.scene2d.InputEvent;
 import com.badlogic.gdx.scenes.scene2d.InputListener;
+import com.badlogic.gdx.scenes.scene2d.actions.Actions;
+import com.badlogic.gdx.utils.TimeUtils;
 
 import java.util.LinkedHashMap;
 
 import cz.nic.tablexia.game.games.pursuit.action.RotateAndMovePieceInPosition;
 import cz.nic.tablexia.game.games.pursuit.action.RotatePieceToClosestAngle;
 import cz.nic.tablexia.game.games.pursuit.helper.ArithmeticsHelper;
+import cz.nic.tablexia.game.games.pursuit.model.Grid;
+import cz.nic.tablexia.util.Log;
 import cz.nic.tablexia.util.Point;
 import cz.nic.tablexia.game.games.pursuit.model.PuzzlePiece;
 
@@ -25,7 +30,9 @@ public class DragAndRotateActorListener extends InputListener {
     private Actor draggedActor;
     private Actor parentActor;
     private IOnRotationFinished iOnRotationFinished;
+    private float actorOriginalRotation;
     private boolean performingAction;
+    private boolean pieceAnimationDone;
 
     private LinkedHashMap<Integer, Point> activePointers;
 
@@ -66,6 +73,7 @@ public class DragAndRotateActorListener extends InputListener {
 
             } else if (activePointers.size() == 2) {
                 initialFingersAngle = (float) ArithmeticsHelper.getAngleBetweenTwoPoints(activePointers.get(activePointers.keySet().toArray()[0]), activePointers.get(activePointers.keySet().toArray()[1]));
+                actorOriginalRotation = draggedActor.getRotation();
             }
         }
         return true;
@@ -99,29 +107,46 @@ public class DragAndRotateActorListener extends InputListener {
     }
 
     @Override
-    public void touchUp(InputEvent event, float x, float y, int pointer, int button) {
+    public void touchUp(InputEvent event, final float x, final float y, int pointer, int button) {
         if(button != 1){
             if (draggedActor != null && !performingAction) {
+                Log.info(getClass(), "TOuch up with pointer: " + pointer);
                 boolean draggingFingerLifted = ((Integer) (activePointers.keySet().toArray()[0]) == pointer);
                 boolean rotatingFingerLifted = false;
                 if (activePointers.size() > 1) {
                     rotatingFingerLifted = (Integer) activePointers.keySet().toArray()[1] == pointer;
                 }
+                Log.info(getClass(), draggingFingerLifted ? "DRAGGING FINGER LIFTED" : rotatingFingerLifted ? "ROTATING FINGER LIFTED" : "WEIIIIRD");
                 activePointers.remove(pointer);
                 if (activePointers.size() == 0) {
-                    dropped(x, y, draggedActor);
+                    Log.info(getClass(), "DROPPED PIECE: " + draggedActor);
+                    if(!isPieceAnimationDone()){
+                        draggedActor.clearActions();
+                        Point pieceOriginalPosition = ((Grid)parentActor).getPieceGridPositionInPixels(((PuzzlePiece)draggedActor).getActualPosition());
+                        parentActor.addAction(new RotateAndMovePieceInPosition((PuzzlePiece) draggedActor,actorOriginalRotation,pieceOriginalPosition , iOnRotationFinished));
+                    }
+                    parentActor.addAction(Actions.after(new Action() {
+                        @Override
+                        public boolean act(float delta) {
+                            dropped(x, y, draggedActor);
+                            return true;
+                        }
+                    }));
                 } else if (activePointers.size() > 0) {
+                    setPieceAnimationDone(false);
                     //if user raised the dragging finger, animate piece under second finger
                     Point currentFirstPointer = activePointers.get(activePointers.keySet().toArray()[0]);
+                    Log.info(getClass(),"Current first Pointer: "+currentFirstPointer);
                     if (draggingFingerLifted) {
                         Vector2 recalculatedCoords = new Vector2(currentFirstPointer.x, currentFirstPointer.y);
                         draggedActor.stageToLocalCoordinates(recalculatedCoords);
                         float bx = draggedActor.getX() + (recalculatedCoords.x - (draggedActor.getWidth() / 2));
                         float by = draggedActor.getY() + (recalculatedCoords.y - (draggedActor.getHeight() / 2));
-
-                        parentActor.addAction(new RotateAndMovePieceInPosition((PuzzlePiece) draggedActor, new Point(bx, by), iOnRotationFinished));
+                        Log.info(getClass(),"ADDING ROTATE AND MOVE ACTION");
+                        parentActor.addAction(new RotateAndMovePieceInPosition((PuzzlePiece) draggedActor,actorOriginalRotation, new Point(bx, by), iOnRotationFinished));
                     } else if (rotatingFingerLifted) {
-                        parentActor.addAction(new RotatePieceToClosestAngle((PuzzlePiece) draggedActor, iOnRotationFinished));
+                        Log.info(getClass(),"ADDING ROTATE ACTION");
+                        parentActor.addAction(new RotatePieceToClosestAngle((PuzzlePiece) draggedActor, actorOriginalRotation,iOnRotationFinished));
                     }
                 }
             } else {
@@ -132,7 +157,7 @@ public class DragAndRotateActorListener extends InputListener {
     }
 
     public interface IOnRotationFinished {
-        void onRotationFinished();
+        void onDragAndRotationFinished();
     }
 
     public void setDraggedActor(Actor actor) {
@@ -150,4 +175,12 @@ public class DragAndRotateActorListener extends InputListener {
     public void setParentActor(Actor parentActor) {
         this.parentActor = parentActor;
     }
+
+    public void setPieceAnimationDone(boolean pieceAnimationDone) {
+        this.pieceAnimationDone = pieceAnimationDone;
+    }
+
+    public boolean isPieceAnimationDone() {
+        return pieceAnimationDone;
+    }
 }