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.bandaged;

import static org.distorted.objectlib.main.TwistyObject.SQ3;

import org.distorted.library.main.DistortedScreen;

import org.distorted.library.mesh.MeshBase;

import org.distorted.library.type.Static3D;

import org.distorted.objectlib.main.InitData;

import org.distorted.objectlib.main.TwistyObject;

import org.distorted.objectlib.shape.ShapeHexahedron;

import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;

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

public class BandagedObjectSkewb extends BandagedObject

{

  float[][] getRotAxis()

    {

    return new float[][]

      {

        { SQ3/3, SQ3/3, SQ3/3 },

        { SQ3/3, SQ3/3,-SQ3/3 },

        { SQ3/3,-SQ3/3, SQ3/3 },

        { SQ3/3,-SQ3/3,-SQ3/3 },

      };

    }

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

  float getDist2D()

    {

    return 0.5f;

    }

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

  int[] getColors()

    {

    return ShapeHexahedron.FACE_COLORS;

    }

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

  boolean isAdjacent(float x1, float y1, float z1, float x2, float y2, float z2 )

    {

    float dx = x1-x2;

    float dy = y1-y2;

    float dz = z1-z2;

    if( dx*dx + dy*dy + dz*dz < 2*1.01f )

      {

      float s = 0.25f*mSize[0]*mSize[0];

      return (x1==x2 && x1*x1==s) || (y1==y2 && y1*y1==s) || (z1==z2 && z1*z1==s);

      }

    return false;

    }

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

  float[][][] getPositions()

    {

    FactoryBandagedSkewb factory = FactoryBandagedSkewb.getInstance();

    return factory.getPositions(mSize);

    }

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

  MeshBase createMesh(float[] pos, boolean round)

    {

    FactoryBandagedSkewb factory = FactoryBandagedSkewb.getInstance();

    return factory.createMesh(pos,mSize,false,round);

    }

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

// PUBLIC API

  public BandagedObjectSkewb(DistortedScreen screen, int minSize, int maxSize)

    {

    super(screen,minSize,maxSize);

    }

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

  public float getScreenRatio()

    {

    return 0.5f;

    }

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

  public float[] getDist3D()

    {

    float d = 0.5f;

    return new float[] {d,d,d,d,d,d};

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlHexahedron.FACE_AXIS;

    }

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

  private float[][] getCuts(int[] numLayers)

    {

    float[] c = numLayers[0]==2 ? (new float[] {0.0f}) : (new float[] {-SQ3/4, SQ3/4});

    return new float[][] {c,c,c,c};

    }

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

  public boolean tryChangeObject(int x, int y, int z)

    {

    if( mSize[0]!=x && x>= mMinSize && x<=mMaxSize )

      {

      mSize[0] = x;

      mSize[1] = x;

      mSize[2] = x;

      mSize[3] = x;

      mMax = x;

      int numCor = FactoryBandagedSkewb.numCorners(x);

      int numEdg = FactoryBandagedSkewb.numEdges(x);

      int numCen = FactoryBandagedSkewb.numCenters(x);

      mNumCubits = numCor + numEdg + numCen;

      mCuts = getCuts(mSize);

      return true;

      }

    else if( mCuts==null )

      {

      mMax = 2;

      int numCor = FactoryBandagedSkewb.numCorners(mMax);

      int numEdg = FactoryBandagedSkewb.numEdges(mMax);

      int numCen = FactoryBandagedSkewb.numCenters(mMax);

      mNumCubits = numCor + numEdg + numCen;

      mCuts = getCuts(mSize);

      return true;

      }

    return false;

    }

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

  public int computeProjectionAngle()

    {

    return 40;

    }

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

  public boolean isInsideFace(int face, float[] p)

    {

    return ( p[0]<=mDist2D && p[0]>=-mDist2D && p[1]<=mDist2D && p[1]>=-mDist2D );

    }

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

  public TwistyObject createObject(int mode, float size)

    {

    float[][] pos = getCubitPositions();

    InitData data = new InitData( mSize,pos);

    return null;//new TwistyBandagedPyraminx( TwistyObject.MESH_NICE, mode, ShapeTetrahedron.DEFAULT_ROT, new Static3D(0,0,0), size, data, null );

    }

}