TwistyPuzzleLib

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

// Copyright 2023 Leszek Koltunski                                                               //

//                                                                                               //

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

//                                                                                               //

// Magic Cube is proprietary software licensed under an EULA which you should have received      //

// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //

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

package org.distorted.objectlib.objects;

import static org.distorted.objectlib.touchcontrol.TouchControl.TC_CHANGING_MIRROR;

import org.distorted.library.effect.EffectName;

import org.distorted.library.type.Static3D;

import org.distorted.library.type.Static4D;

import org.distorted.objectlib.helpers.ObjectFaceShape;

import org.distorted.objectlib.helpers.ObjectShape;

import org.distorted.objectlib.helpers.ObjectSignature;

import org.distorted.objectlib.helpers.ObjectVertexEffects;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.ObjectType;

import java.io.InputStream;

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

public class TwistyCamouflage extends TwistyBandagedAbstract

{

  private static final float SIZE_CORRECTION = 1.18f;

  public static final float[][] CAM_333 = new float[][]

    {

      getCenters( -1.0f, 1.0f, 1.0f, 2, 2, 2),

      getCenters(  0.5f, 1.0f, 1.0f, 1, 2, 2),

      getCenters(  1.5f, 1.0f, 1.0f, 1, 2, 2),

      getCenters( -1.0f,-0.5f, 1.0f, 2, 1, 2),

      getCenters( -1.0f,-1.5f, 1.0f, 2, 1, 2),

      getCenters( -1.0f, 1.0f,-0.5f, 2, 2, 1),

      getCenters( -1.0f, 1.0f,-1.5f, 2, 2, 1),

      getCenters( -1.0f,-1.5f,-0.5f, 2, 1, 1),

      getCenters( -1.0f,-1.5f,-1.5f, 2, 1, 1),

      getCenters( -1.0f,-0.5f,-0.5f, 2, 1, 1),

      getCenters( -1.0f,-0.5f,-1.5f, 2, 1, 1),

      getCenters(  0.5f, 1.0f,-1.5f, 1, 2, 1),

      getCenters(  1.5f, 1.0f,-1.5f, 1, 2, 1),

      getCenters(  0.5f, 1.0f,-0.5f, 1, 2, 1),

      getCenters(  1.5f, 1.0f,-0.5f, 1, 2, 1),

      getCenters(  0.5f,-0.5f, 1.0f, 1, 1, 2),

      getCenters(  1.5f,-0.5f, 1.0f, 1, 1, 2),

      getCenters(  0.5f,-1.5f, 1.0f, 1, 1, 2),

      getCenters(  1.5f,-1.5f, 1.0f, 1, 1, 2),

      getCenters(  0.5f,-0.5f,-1.5f, 1, 1, 1),

      getCenters(  1.5f,-0.5f,-1.5f, 1, 1, 1),

      getCenters(  0.5f,-1.5f,-1.5f, 1, 1, 1),

      getCenters(  1.5f,-1.5f,-1.5f, 1, 1, 1),

      getCenters(  0.5f,-1.5f,-0.5f, 1, 1, 1),

      getCenters(  1.5f,-0.5f,-0.5f, 1, 1, 1),

      getCenters(  1.5f,-1.5f,-0.5f, 1, 1, 1),

    };

  private static final int[][] DIMS = new int[][]

    {

      {2,2,2},

      {1,2,2},

      {2,1,2},

      {2,2,1},

      {2,1,1},

      {1,2,1},

      {1,1,2},

      {1,1,1},

    };

  private static final float[][] OFFSETS = new float[][]

    {

      { 0.0f, 0.0f, 0.0f},

      { 0.5f, 0.0f, 0.0f},

      {-0.5f, 0.0f, 0.0f},

      { 0.0f, 0.5f, 0.0f},

      { 0.0f,-0.5f, 0.0f},

      { 0.0f, 0.0f, 0.5f},

      { 0.0f, 0.0f,-0.5f},

      { 0.0f,-0.5f,-0.5f},

      { 0.5f, 0.0f,-0.5f},

      { 0.5f,-0.5f, 0.0f},

      { 0.5f,-0.5f,-0.5f},

    };

  private int[] mDimsIndices, mOffsIndices;

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

  private static float[] getCenters( float x, float y, float z, int xd, int yd, int zd )

    {

    float XS = 0.5f*(1-xd) + x;

    float YS = 0.5f*(1-yd) + y;

    float ZS = 0.5f*(1-zd) + z;

    int index=0;

    float[] result = new float[3*xd*yd*zd];

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

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

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

          {

          result[3*index  ] = XS+i;

          result[3*index+1] = YS+j;

          result[3*index+2] = ZS+k;

          index++;

          }

    return result;

    }

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

  public TwistyCamouflage(InitData data, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)

    {

    super(data, meshState, iconMode, SIZE_CORRECTION*(data.getNumLayers()[0]+data.getNumLayers()[1]+data.getNumLayers()[2])/3.0f, quat, move, scale, stream);

    }

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

  @Override

  public int getInternalColor()

    {

    return 0xff333333;

    }

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

  @Override

  public int getScrambleType()

    {

    return 2;

    }

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

  public int[][] getScrambleEdges()

    {

    return null;

    }

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

  private int getDimsIndex(int variant)

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    if( mPosition==CAM_333 )

      {

      if( mDimsIndices==null ) mDimsIndices = new int[]

                                   { 0,

                                     1,0,2,0,3,0,

                                     3,0,4,2,1,0,5,3,6,2,1,0,

                                     6,2,1,0,5,4,3 };

      }

    return mDimsIndices[variant];

    }

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

  private int getOffsetsIndex(int variant)

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    if( mPosition==CAM_333 )

      {

      if( mOffsIndices==null ) mOffsIndices = new int[]

                                   { 0,

                                     0,1,0,4,0,6,

                                     4,7,0,6,6,8,0,1,0,1,4,9,

                                     6,8,7,10,4,1,9 };

      }

    return mOffsIndices[variant];

    }

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

  private float[][] getVertices(int variant)

    {

    int indexD = getDimsIndex(variant);

    int X=DIMS[indexD][0];

    int Y=DIMS[indexD][1];

    int Z=DIMS[indexD][2];

    int indexO = getOffsetsIndex(variant);

    float XF = OFFSETS[indexO][0];

    float YF = OFFSETS[indexO][1];

    float ZF = OFFSETS[indexO][2];

    return new float[][]

      {

        { 0.5f*X +XF, 0.5f*Y +YF, 0.5f*Z +ZF},

        { 0.5f*X +XF, 0.5f*Y +YF,-0.5f*Z +ZF},

        { 0.5f*X +XF,-0.5f*Y +YF, 0.5f*Z +ZF},

        { 0.5f*X +XF,-0.5f*Y +YF,-0.5f*Z +ZF},

        {-0.5f*X +XF, 0.5f*Y +YF, 0.5f*Z +ZF},

        {-0.5f*X +XF, 0.5f*Y +YF,-0.5f*Z +ZF},

        {-0.5f*X +XF,-0.5f*Y +YF, 0.5f*Z +ZF},

        {-0.5f*X +XF,-0.5f*Y +YF,-0.5f*Z +ZF}

      };

    }

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

// PUBLIC API

  public int getTouchControlType()

    {

    return TC_CHANGING_MIRROR;

    }

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

  public float[] getDist3D(int[] numLayers)

    {

    float x = numLayers[0];

    float y = numLayers[1];

    float z = numLayers[2];

    float a = SIZE_CORRECTION*(x+y+z)/1.5f;

    return new float[] {(x+2)/a,x/a,y/a,(y+2)/a,z/a,(z+2)/a};

    }

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

  public Static4D getCubitQuats(int cubit, int[] numLayers)

    {

    return mObjectQuats[0];

    }

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

  public ObjectShape getObjectShape(int variant)

    {

    int[][] indices =

        {

          {2,3,1,0},

          {7,6,4,5},

          {4,0,1,5},

          {7,3,2,6},

          {6,2,0,4},

          {3,7,5,1},

        };

    return new ObjectShape( getVertices(variant), indices);

    }

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

  public ObjectFaceShape getObjectFaceShape(int variant)

    {

    int index = getDimsIndex(variant);

    int X = DIMS[index][0];

    int Y = DIMS[index][1];

    int Z = DIMS[index][2];

    float height     = isInIconMode() ? 0.001f : 0.03f;

    int[] bandIndices= { 0,0,1,1,2,2 };

    int maxXY = Math.max(X,Y);

    int maxXZ = Math.max(X,Z);

    int maxYZ = Math.max(Y,Z);

    int angle = 45;

    float R = 0.10f;

    float S = 0.25f;

    float N = 4;

    float[][] bands =

        {

          {height/maxYZ,angle,R,S,N,0,0},

          {height/maxXZ,angle,R,S,N,0,0},

          {height/maxXY,angle,R,S,N,0,0}

        };

    return new ObjectFaceShape(bands,bandIndices,null);

    }

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

  public ObjectVertexEffects getVertexEffects(int variant)

    {

    boolean round = false;

    float[][] vertices = getVertices(variant);

    float A = -0.03f;

    float[][] variables =

        {

          { 0, A, A, A, 1  },

          { 0, A, A,-A, 1  },

          { 0, A,-A, A, 1  },

          { 0, A,-A,-A, 1  },

          { 0,-A, A, A, 1  },

          { 0,-A, A,-A, 1  },

          { 0,-A,-A, A, 1  },

          { 0,-A,-A,-A, 1  },

        };

    String name = EffectName.DEFORM.name();

    float[] reg = {0,0,0,0.10f};

    String[] names = {name,name,name,name,name,name,name,name};

    float[][] regions = {reg,reg,reg,reg,reg,reg,reg,reg};

    boolean[] uses = {round,round,round,round,round,round,round,round};

    return new ObjectVertexEffects(names,variables,vertices,regions,uses);

    }

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

  public int getCubitVariant(int cubit, int[] numLayers)

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    if( mPosition==CAM_333 )

      {

      return cubit;

      }

    return 0;

    }

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

  public int getNumCubitVariants(int[] numLayers)

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    if( mPosition==CAM_333 ) return 26;

    return 0;

    }

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

  public float getStickerRadius()

    {

    return 0.18f;

    }

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

  public float getStickerStroke()

    {

    return isInIconMode() ? 0.30f : 0.18f;

    }

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

  public String getShortName()

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    if( mPosition==CAM_333 ) return ObjectType.CA_333.name();

    return null;

    }

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

  public ObjectSignature getSignature()

    {

    if( mSignature==null )

      {

      if( mPosition==null ) mPosition = getInitData().getPos();

      if( mPosition==CAM_333 ) mSignature = new ObjectSignature(ObjectType.CA_333);

      }

    return mSignature;

    }

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

  public String getObjectName()

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    if( mPosition==CAM_333 ) return "Camouflage 3x3x3";

    return "Camouflage";

    }

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

  public String getInventor()

    {

    return "Guan Yang";

    }

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

  public int getYearOfInvention()

    {

    return 2013;

    }

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

  public int getComplexity()

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    if( mPosition==CAM_333 ) return 3;

    return 0;

    }

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

  public String[][] getTutorials()

    {

    if( mPosition==null ) mPosition = getInitData().getPos();

    if( mPosition==CAM_333 )

      {

      return new String[][]{

                            {"gb","f9zmpCfg25k","3x3x3 Camouflage Part 1","Superantoniovivaldi"},

                            {"gb","O8pGyi5Juxk","3x3x3 Camouflage Part 2","Superantoniovivaldi"},

                            {"es","V1RPBIzEwp4","Tutorial 3x3 Camouflage","Manu rubiks"},

                            {"ru","DRGNOSw5pPc","Как собрать 3х3х3 camouflage","Илья Топор-Гилка"},

                            {"fr","9BfI1Fcbcl8","Résolution du Camouflage Cube","Skieur Cubb"},

                            {"pl","uEVvR2jDdI0","Camouflage 3x3x3 Tutorial","MrUK"},

                           };

      }

    return null;

    }

}