Magic Cube

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

// Copyright 2020 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.patterns;

import java.util.Vector;

import android.graphics.Paint;

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

public class RubikPattern

{

  private static final int MIN_CUBE  = 2;

  private static final int MAX_CUBE  = 5;

  public  static final int NUM_CUBES = MAX_CUBE-MIN_CUBE+1;

  public int[] numCategories = new int[NUM_CUBES];

  private static String buffer="";

  private static Paint mPaint = new Paint();

  private static int width;

  private Vector<Category>[] mCategories;

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

  private class Category

    {

    private String name;

    private int numpatterns;

    private Vector<Pattern> patterns;

    private int curPattern;

    public Category(String n)

      {

      name=n;

      curPattern=0;

      numpatterns=0;

      patterns = new Vector<>();

      }

    public void addPattern(Pattern p)

      {

      patterns.addElement(p);

      numpatterns++;

      }

    public int getNumPatterns()

    {

    return numpatterns;

    };

    public String getName()

    {

    return name;

    }

    public void next()

      {

      curPattern++;

      if( curPattern>=numpatterns )

        curPattern=0;

      }

    public void prev()

      {

      curPattern--;

      if( curPattern<0 )

        curPattern=numpatterns-1;

      }

    public String getPatternName()

      {

      Pattern p = patterns.elementAt(curPattern);

      return  p!=null ? p.getName(curPattern+1,numpatterns):null;

      }

    public int getPatternCurMove()

      {

      Pattern p = patterns.elementAt(curPattern);

      return  p!=null ? p.getCurMove():-1;

      }

    public int getPatternNumMove()

      {

      Pattern p = patterns.elementAt(curPattern);

      return  p!=null ? p.getNumMove():-1;

      }

    public void initializeCube()

      {

      Pattern p = patterns.elementAt(curPattern);

      if( p!=null ) p.initializeCube();

      }

    public void makeNextMove()

      {

      Pattern p = patterns.elementAt(curPattern);

      if( p!=null ) p.makeNextMove();

      }

    public void makePrevMove()

      {

      Pattern p = patterns.elementAt(curPattern);

      if( p!=null ) p.makePrevMove();

      }

    }

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

  private class Pattern

    {

    private String name;

    private String shortname=null;

    private String moves;

    private int curmove;

    private int nummove;

    public Pattern(String n, String m)

      {

      name=n;

      moves=m;

      nummove = moves.length()/4;

      curmove=nummove;

      }

    public String getName(int cur,int num)

      {

      if( shortname==null ) shortname=cutPatternName(name);

      return shortname;

      }

    public int getNumMove()

    {

    return nummove;

    }

    public int getCurMove()

    {

    return curmove;

    }

    public void makeNextMove()

      {

      curmove++;

      if( curmove>nummove)

        {

        curmove= 0;

        initializeCube();

        }

      else

        {

// TODO

//        RubikCube cube = world.getCube();

//        if( cube!=null && !cube.makeMove(moves.substring(4*curmove-4,4*curmove)) )

          curmove--;

        }

      }

    public void makePrevMove()

      {

      curmove--;

      if( curmove<0)

        {

        curmove=nummove;

        initializeCube();

        }

      else

        {

// TODO

//        RubikCube cube = world.getCube();

//        if( cube!=null && !cube.backMove(moves.substring(4*curmove,4*curmove+4)) )

          curmove++;

        }

      }

    public void initializeCube()

      {

// TODO

//	    RubikCube cube = world.getCube();

//      if( cube!=null ) cube.setupPosition(moves.substring(0,4*curmove));

      }

    }

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

  public RubikPattern(int wi, int h)

    {

    width = wi;

    mCategories = new Vector[NUM_CUBES];

    mPaint.setTextSize(h);

    initializeCategories(0, RubikPatternData2.patterns);

    initializeCategories(1, RubikPatternData3.patterns);

    initializeCategories(2, RubikPatternData4.patterns);

    initializeCategories(3, RubikPatternData5.patterns);

    }

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

  private void initializeCategories(int num, String[] pat)

    {

    int colon;

    mCategories[num] = new Vector<>();

    Category cat=null;

    String name, pattern;

    Pattern patt;

    numCategories[num]=0;

    for(String p: pat)

      {

      colon = p.indexOf(':');

      if( colon==-1 )

        {

        cat = new Category(p);

        mCategories[num].addElement(cat);

        numCategories[num]++;

        }

      else

        {

        pattern = p.substring(colon+1);

        name    = p.substring(0,colon);

        patt = new Pattern(name,pattern);

        cat.addPattern(patt);

        }

      }

    }

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

  private static String cutPatternName(String n)

    {

    int len1 = (int)mPaint.measureText(n);

    if( len1>width )

      {

      int l = n.length();

      while( l>=2 && len1>width )

        {

        l--;

        buffer = n.substring(0,l);

        len1 = (int)mPaint.measureText(buffer);

        }

      return buffer+"...";

      }

    return n;

    }

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

  public String getCategoryName(int size,int num)

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.getName() : null;

      }

    return null;

    }

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

  public String getPatternName(int size,int num)

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.getPatternName() : null;

      }

    return null;

    }

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

  public int getNumPatterns(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.getNumPatterns() : 0;

      }

    return 0;

    }

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

  public void nextPattern(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      if( c!=null )

        {

// TODO

//        RubikMenu.texDirty[0] = true;

        c.next();

        c.initializeCube();

        }

      }

    }

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

  public void prevPattern(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      if( c!=null )

        {

// TODO

//        RubikMenu.texDirty[0] = true;

        c.prev();

        c.initializeCube();

        }

      }

    }

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

  public int getCurrPattern(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.curPattern:0;

      }

    return 0;

    }

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

  public int getCurMove(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.getPatternCurMove():0;

      }

    return 0;

    }

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

  public int getNumMove(int size, int num )

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      return c!=null ? c.getPatternNumMove():0;

      }

    return 0;

    }

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

  public void makeNextMove(int size, int num)

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      if( c!=null ) c.makeNextMove();

      }

    }

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

  public void makePrevMove(int size, int num)

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      if( c!=null ) c.makePrevMove();

      }

    }

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

  public void initializeCube(int size,int num)

    {

    if( size>=MIN_CUBE && size<=MAX_CUBE && num>=0 && num< numCategories[size-MIN_CUBE] )

      {

      Category c = mCategories[size-MIN_CUBE].elementAt(num);

      if( c!=null ) c.initializeCube();

      }

    }

}