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

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

class Tablebase

{

  private final byte UNINITIALIZED = (byte)0xff;

  private final byte[] mUnpackedTable;

  private byte[] mPackedTable;

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

  Tablebase(int size)

    {

    mUnpackedTable = new byte[size];

    for(int i=0; i<size; i++) mUnpackedTable[i] = UNINITIALIZED;

    }

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

  boolean insertUnpacked(int index, byte value)

    {

    if( mUnpackedTable[index]==UNINITIALIZED )

      {

      mUnpackedTable[index] = value;

      return true;

      }

    return false;

    }

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

  byte retrieveUnpacked(int index)

    {

    return mUnpackedTable[index];

    }

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

  private void createPacked(int size)

    {

    mPackedTable = new byte[(size+4)/5];

    }

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

  private void insertPacked(int index, byte value)

    {

    int indexToInsert = index/5;

    byte actualInserted = (byte)(value%3);

    int val = mPackedTable[indexToInsert] & 0xff; // convert to 'unsigned'

    int b0 = val%3; val/=3;

    int b1 = val%3; val/=3;

    int b2 = val%3; val/=3;

    int b3 = val%3; val/=3;

    int b4 = val%3;

    switch(index%5)

      {

      case 0: b0 = actualInserted; break;

      case 1: b1 = actualInserted; break;

      case 2: b2 = actualInserted; break;

      case 3: b3 = actualInserted; break;

      case 4: b4 = actualInserted; break;

      }

    mPackedTable[indexToInsert] = (byte)(b0 + 3*(b1 + 3*(b2 + 3*(b3 + 3*b4))));

    }

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

  byte retrievePacked(int index)

    {

    int indexToRetrieve = index/5;

    int val = mPackedTable[indexToRetrieve] & 0xff; // convert to 'unsigned'

    int offset = (index%5);

    if(offset==0) return (byte)(val%3);

    val/=3;

    if(offset==1) return (byte)(val%3);

    val/=3;

    if(offset==2) return (byte)(val%3);

    val/=3;

    if(offset==3) return (byte)(val%3);

    val/=3;

    return (byte)(val%3);

    }

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

  void pack()

    {

    int size = mUnpackedTable.length;

    createPacked(size);

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

      {

      byte unpacked = retrieveUnpacked(i);

      insertPacked(i,unpacked);

      }

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

      {

      byte unpacked = retrieveUnpacked(i);

      byte packed = retrievePacked(i);

      String m = "index="+i+" offset="+(i%5)+" unpacked="+unpacked+" packed="+packed;

      if( ((unpacked%3) != packed) ) android.util.Log.e("D", m);

      else android.util.Log.d("D", m);

      }

    }

}