Magic Cube

///////////////////////////////////////////////////////////////////////////////////////////////////

// Copyright 2019 Leszek Koltunski                                                               //

//                                                                                               //

// This file is part of Magic Cube.                                                              //

//                                                                                               //

// Magic Cube is free software: you can redistribute it and/or modify                            //

// it under the terms of the GNU General Public License as published by                          //

// the Free Software Foundation, either version 2 of the License, or                             //

// (at your option) any later version.                                                           //

//                                                                                               //

// Magic Cube is distributed in the hope that it will be useful,                                 //

// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //

// GNU General Public License for more details.                                                  //

//                                                                                               //

// You should have received a copy of the GNU General Public License                             //

// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //

///////////////////////////////////////////////////////////////////////////////////////////////////

package org.distorted.object;

import android.content.SharedPreferences;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import org.distorted.library.effect.Effect;

import org.distorted.library.main.DistortedEffects;

import org.distorted.library.main.DistortedTexture;

import org.distorted.library.mesh.MeshCubes;

import org.distorted.library.mesh.MeshRectangles;

import org.distorted.library.message.EffectListener;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import static org.distorted.object.RubikObjectList.VECTX;

import static org.distorted.object.RubikObjectList.VECTY;

import static org.distorted.object.RubikObjectList.VECTZ;

///////////////////////////////////////////////////////////////////////////////////////////////////

class RubikCube extends RubikObject

{

    private static final Static3D VectX = new Static3D(1,0,0);

    private static final Static3D VectY = new Static3D(0,1,0);

    private static final Static3D VectZ = new Static3D(0,0,1);

    private static final Static4D mapFront, mapBack, mapLeft, mapRight, mapTop, mapBottom, mapBlack;

    private Cubit[][][] mCubits;

    static

      {

      // 3x2 bitmap = 6 squares:

      //

      // RED     GREEN   BLUE

      // YELLOW  WHITE   BROWN

      final float ze = 0.0f;

      final float ot = 1.0f/3.0f;

      final float tt = 2.0f/3.0f;

      final float oh = 1.0f/2.0f;

      final float of = 1.0f/40.0f;

      mapFront = new Static4D(ze,oh, ze+ot,oh+oh);

      mapBack  = new Static4D(tt,ze, tt+ot,ze+oh);

      mapLeft  = new Static4D(ot,ze, ot+ot,ze+oh);

      mapRight = new Static4D(ze,ze, ze+ot,ze+oh);

      mapTop   = new Static4D(tt,oh, tt+ot,oh+oh);

      mapBottom= new Static4D(ot,oh, ot+ot,oh+oh);

      mapBlack = new Static4D(ze,ze, ze+of,ze+of);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

// All legal rotation quats of a RubikCube of any size must have all four of their components

// equal to either 0, 1, -1, 0.5, -0.5 or +-sqrt(2)/2.

    float[] getLegalQuats()

      {

      final float SQ2 = 0.5f*((float)Math.sqrt(2));

      return new float[] { 0.0f , 0.5f , -0.5f , 1.0f , -1.0f , SQ2 , -SQ2 };

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    private boolean belongsToRotation( Static3D currentPosition, int vector, int row)

      {

      switch(vector)

        {

        case VECTX: return currentPosition.get0()==row;

        case VECTY: return currentPosition.get1()==row;

        case VECTZ: return currentPosition.get2()==row;

        }

      return false;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

    RubikCube(int size, Static4D quatCur, Static4D quatAcc, DistortedTexture texture, MeshRectangles mesh, DistortedEffects effects)

      {

      super(size,quatCur,quatAcc,texture,mesh,effects);

      mTexture = new DistortedTexture(TEXTURE_SIZE,TEXTURE_SIZE);

      mCubits  = new Cubit[mSize][mSize][mSize];

      int vertices = (int)(24.0f/mSize + 2.0f);

      for(int x = 0; x< mSize; x++)

        for(int y = 0; y< mSize; y++)

          for(int z = 0; z< mSize; z++)

            {

            if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

              {

              mCubits[x][y][z] = new Cubit( this,createMesh(vertices,x,y,z),new Static3D(x,y,z) );

              attach(mCubits[x][y][z].mNode);

              }

            }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

// PUBLIC API

///////////////////////////////////////////////////////////////////////////////////////////////////

// mSize already saved as RubikStatePlay.mButton

   public void savePreferences(SharedPreferences.Editor editor)

     {

     for(int x=0; x<mSize; x++)

        for(int y=0; y<mSize; y++)

          for(int z=0; z<mSize; z++)

            if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

              {

              mCubits[x][y][z].savePreferences(editor);

              }

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public void restorePreferences(SharedPreferences preferences)

     {

     for(int x=0; x<mSize; x++)

        for(int y=0; y<mSize; y++)

          for(int z=0; z<mSize; z++)

            if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

              {

              mCubits[x][y][z].restorePreferences(preferences);

              }

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public long finishRotationNow(EffectListener listener)

     {

     boolean first = true;

     long effectID=0;

     for(int x=0; x<mSize; x++)

       for(int y=0; y<mSize; y++)

         for(int z=0; z<mSize; z++)

           if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

             {

             if( belongsToRotation(mCubits[x][y][z].mCurrentPosition,mRotAxis,mRotRow) )

               {

               if( first )

                 {

                 first = false;

                 effectID = mCubits[x][y][z].finishRotationNow(listener);

                 }

               resetRotationAngle(mCubits[x][y][z].mRotationAngle);

               }

             }

     return effectID;

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public void releaseResources()

     {

     mTexture.markForDeletion();

     for(int x=0; x<mSize; x++)

       for(int y=0; y<mSize; y++)

         for(int z=0; z<mSize; z++)

           {

           if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

             {

             mCubits[x][y][z].releaseResources();

             }

           }

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public void apply(Effect effect, int position)

     {

     for(int x=0; x<mSize; x++)

       for(int y=0; y<mSize; y++)

         for(int z=0; z<mSize; z++)

           {

           if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

             {

             mCubits[x][y][z].mEffect.apply(effect, position);

             }

           }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public void remove(long effectID)

     {

     for(int x=0; x<mSize; x++)

       for(int y=0; y<mSize; y++)

         for(int z=0; z<mSize; z++)

           {

           if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

             {

             mCubits[x][y][z].mEffect.abortById(effectID);

             }

           }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public void solve()

     {

     for(int x=0; x<mSize; x++)

       for(int y=0; y<mSize; y++)

         for(int z=0; z<mSize; z++)

           if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

             {

             mCubits[x][y][z].solve();

             }

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public boolean isSolved()

     {

     Static4D q = mCubits[0][0][0].mQuatScramble;

     float x = q.get0();

     float y = q.get1();

     float z = q.get2();

     float w = q.get3();

     for(int i = 0; i< mSize; i++)

       for(int j = 0; j< mSize; j++)

         for(int k = 0; k< mSize; k++)

           {

           if( i==0 || i==mSize-1 || j==0 || j==mSize-1 || k==0 || k==mSize-1 )

             {

             q = mCubits[i][j][k].mQuatScramble;

             if( q.get0()!=x || q.get1()!=y || q.get2()!=z || q.get3()!=w )

               {

               return false;

               }

             }

           }

     return true;

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public void beginNewRotation(int vector, int row )

     {

     Static3D axis = VectX;

     switch(vector)

       {

       case VECTX: axis = VectX; break;

       case VECTY: axis = VectY; break;

       case VECTZ: axis = VectZ; break;

       }

     mRotAxis = vector;

     mRotRow  = row;

     mRotationAngleStatic.set0(0.0f);

     for(int x=0; x<mSize; x++)

       for(int y=0; y<mSize; y++)

         for(int z=0; z<mSize; z++)

           if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

             {

             if( belongsToRotation( mCubits[x][y][z].mCurrentPosition,vector,mRotRow) )

               {

               mCubits[x][y][z].beginNewRotation(axis);

               }

             }

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public long addNewRotation(int vector, int row, int angle, long durationMillis, EffectListener listener )

      {

      Static3D axis = VectX;

      long effectID=0;

      boolean first = true;

      switch(vector)

        {

        case VECTX: axis = VectX; break;

        case VECTY: axis = VectY; break;

        case VECTZ: axis = VectZ; break;

        }

      mRotAxis = vector;

      mRotRow  = row;

      mRotationAngleStatic.set0(0.0f);

      for(int x=0; x<mSize; x++)

        for(int y=0; y<mSize; y++)

          for(int z=0; z<mSize; z++)

            if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

              {

              if( belongsToRotation(mCubits[x][y][z].mCurrentPosition,vector,mRotRow) )

                {

                mCubits[x][y][z].addNewRotation(axis,durationMillis,angle);

                if( first )

                  {

                  first = false;

                  effectID = mCubits[x][y][z].setUpCallback(listener);

                  }

                }

              }

      return effectID;

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public void removeRotationNow()

      {

      float qx=0,qy=0,qz=0;

      boolean first = true;

      Static4D quat = null;

      switch(mRotAxis)

        {

        case VECTX: qx=1; break;

        case VECTY: qy=1; break;

        case VECTZ: qz=1; break;

        }

      for(int x=0; x<mSize; x++)

        for(int y=0; y<mSize; y++)

          for(int z=0; z<mSize; z++)

            if( x==0 || x==mSize-1 || y==0 || y==mSize-1 || z==0 || z==mSize-1 )

              {

              if( belongsToRotation(mCubits[x][y][z].mCurrentPosition,mRotAxis,mRotRow) )

                {

                if( first )

                  {

                  first = false;

                  quat = mCubits[x][y][z].returnRotationQuat(qx,qy,qz);

                  }

                mCubits[x][y][z].removeRotationNow(quat);

                }

              }

      mRotationAngleStatic.set0(0);

      }

///////////////////////////////////////////////////////////////////////////////////////////////////

   public void createTexture()

     {

     Bitmap bitmap;

     final int S = 128;

     final int W = 3*S;

     final int H = 2*S;

     final int R = S/10;

     final int M = S/20;

     Paint paint = new Paint();

     bitmap = Bitmap.createBitmap(W,H, Bitmap.Config.ARGB_8888);

     Canvas canvas = new Canvas(bitmap);

     paint.setAntiAlias(true);

     paint.setTextAlign(Paint.Align.CENTER);

     paint.setStyle(Paint.Style.FILL);

     // 3x2 bitmap = 6 squares:

     //

     // RED     GREEN   BLUE

     // YELLOW  WHITE   BROWN

     paint.setColor(0xff000000);                                  // BLACK BACKGROUND

     canvas.drawRect(0, 0, W, H, paint);                          //

     paint.setColor(0xffff0000);                                  // RED

     canvas.drawRoundRect(    M,   M,   S-M,   S-M, R, R, paint); //

     paint.setColor(0xff00ff00);                                  // GREEN

     canvas.drawRoundRect(  S+M,   M, 2*S-M,   S-M, R, R, paint); //

     paint.setColor(0xff0000ff);                                  // BLUE

     canvas.drawRoundRect(2*S+M,   M, 3*S-M,   S-M, R, R, paint); //

     paint.setColor(0xffffff00);                                  // YELLOW

     canvas.drawRoundRect(    M, S+M,   S-M, 2*S-M, R, R, paint); //

     paint.setColor(0xffffffff);                                  // WHITE

     canvas.drawRoundRect(  S+M, S+M, 2*S-M, 2*S-M, R, R, paint); //

     paint.setColor(0xffb5651d);                                  // BROWN

     canvas.drawRoundRect(2*S+M, S+M, 3*S-M, 2*S-M, R, R, paint); //

     mTexture.setTexture(bitmap);

     }

///////////////////////////////////////////////////////////////////////////////////////////////////

   private MeshCubes createMesh(int vertices,int x, int y, int z)

     {

     Static4D tmpLeft  = (x==       0 ? mapLeft  :mapBlack);

     Static4D tmpRight = (x== mSize-1 ? mapRight :mapBlack);

     Static4D tmpFront = (z== mSize-1 ? mapFront :mapBlack);

     Static4D tmpBack  = (z==       0 ? mapBack  :mapBlack);

     Static4D tmpTop   = (y== mSize-1 ? mapTop   :mapBlack);

     Static4D tmpBottom= (y==       0 ? mapBottom:mapBlack);

     return new MeshCubes(vertices,vertices,vertices, tmpFront, tmpBack, tmpLeft, tmpRight, tmpTop, tmpBottom);

     }

}