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 static org.distorted.objectlib.main.TwistyObject.SQ6;

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.objects.TwistyBandagedPyraminx;

import org.distorted.objectlib.shape.ShapeTetrahedron;

import org.distorted.objectlib.touchcontrol.TouchControlTetrahedron;

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

public class BandagedObjectPyraminx extends BandagedObject

{

  private boolean isFaceInverted(int face)

    {

    return face>1;

    }

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

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

    {

    int numL = numLayers[0];

    float[][] ret = new float[4][numL-1];

    for(int i=0; i<numL-1; i++)

      {

      float cut = (1.0f+i-numL/4.0f)*(SQ6/3);

      ret[0][i] = cut;

      ret[1][i] = cut;

      ret[2][i] = cut;

      ret[3][i] = cut;

      }

    return ret;

    }

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

  float[][] getRotAxis()

    {

    return new float[][]

      {

        {     0,-SQ3/3,-SQ6/3 },

        {     0,-SQ3/3, SQ6/3 },

        { SQ6/3, SQ3/3,     0 },

        {-SQ6/3, SQ3/3,     0 },

      };

    }

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

  float getDist2D()

    {

    return SQ3/6;

    }

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

  int[] getColors()

    {

    return ShapeTetrahedron.FACE_COLORS;

    }

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

  boolean isAdjacent(float dx, float dy, float dz)

    {

    return dx*dx + dy*dy + dz*dz < (SQ3/4)*1.01f;

    }

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

  float[][][] getPositions()

    {

    FactoryBandagedPyraminx factory = FactoryBandagedPyraminx.getInstance();

    return factory.getPositions(mSize);

    }

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

  MeshBase createMesh(float[] pos, boolean round)

    {

    FactoryBandagedPyraminx factory = FactoryBandagedPyraminx.getInstance();

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

    }

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

// PUBLIC API

  public BandagedObjectPyraminx(DistortedScreen screen)

    {

    super(screen);

    }

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

  public float getScreenRatio()

    {

    return 0.8f;

    }

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

  public float[] getDist3D()

    {

    float d = SQ6/12;

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

    }

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

  public Static3D[] getFaceAxis()

    {

    return TouchControlTetrahedron.FACE_AXIS;

    }

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

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

    {

    if( mSize[0]!=x )

      {

      mSize[0] = x;

      mSize[1] = x;

      mSize[2] = x;

      mSize[3] = x;

      mMax = x;

      int numOcta = FactoryBandagedPyraminx.numEntriesInEmptyLattice(x-1);

      int numTetra= FactoryBandagedPyraminx.numEntriesInEmptyLattice(x);

      mNumCubits = numOcta + numTetra;

      mCuts = getCuts(mSize);

      return true;

      }

    return false;

    }

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

  public int computeProjectionAngle()

    {

    return 120;

    }

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

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

    {

    float y = (isFaceInverted(face) ? p[1] : -p[1]);

    float x = p[0];

    return (y >= -mDist2D) && (y <= mDist2D*(2-6*x)) && (y <= mDist2D*(2+6*x));

    }

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

  public TwistyObject createObject(int mode, float size)

    {

    float[][] pos = getCubitPositions();

    InitData data = new InitData( mSize,pos);

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

    }

}