Magic Cube

import org.distorted.object.RubikObject;

    for (int i = 0; i< RubikObject.LENGTH; i++)

      imageView.setImageResource(RubikObject.getObject(i).getIconID());

import org.distorted.network.RubikScoresDownloader;

import org.distorted.object.RubikObject;

    for(int i = 0; i< RubikObject.LENGTH; i++)

        for(int i = 0; i< RubikObject.LENGTH; i++)

        for(int i = 0; i< RubikObject.LENGTH; i++)

    mViews = new RubikDialogScoresView[RubikObject.LENGTH];

    viewPager.setOffscreenPageLimit( RubikObject.LENGTH-1 );

    for(int i = 0; i< RubikObject.LENGTH; i++)

    return RubikObject.LENGTH;

import org.distorted.network.RubikScoresDownloader;

import org.distorted.network.RubikScoresDownloader;

import org.distorted.object.RubikObject;

      if( id>=0 && id< RubikObject.LENGTH )

        int size = RubikObject.getObject(id).getObjectSize();

import org.distorted.object.RubikObject;

      mNextCubeSize = RubikObject.getObject(size).getObjectSize();

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

// Copyright 2019 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.network;

import android.content.res.Resources;

import java.io.InputStream;

import java.net.HttpURLConnection;

import java.net.URL;

import java.net.UnknownHostException;

import org.distorted.magic.R;

import org.distorted.object.RubikObject;

import org.distorted.uistate.RubikStatePlay;

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

public class RubikScoresDownloader implements Runnable

  {

  public interface Receiver

    {

    void receive(int[][][] country, String[][][] name, String[][][] time);

    void exception(String exception);

    }

  public static final int MAX_PLACES = 12;

  private static final int DOWNLOAD   = 0;

  private static final int SUBMIT     = 1;

  private static final int IDLE       = 2;

  private static final String URL  ="http://koltunski.pl/rubik/cgi-bin";

  private final String[] hex = {

    "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",

    "%08", "%09", "%0a", "%0b", "%0c", "%0d", "%0e", "%0f",

    "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",

    "%18", "%19", "%1a", "%1b", "%1c", "%1d", "%1e", "%1f",

    "%20", "%21", "%22", "%23", "%24", "%25", "%26", "%27",

    "%28", "%29", "%2a", "%2b", "%2c", "%2d", "%2e", "%2f",

    "%30", "%31", "%32", "%33", "%34", "%35", "%36", "%37",

    "%38", "%39", "%3a", "%3b", "%3c", "%3d", "%3e", "%3f",

    "%40", "%41", "%42", "%43", "%44", "%45", "%46", "%47",

    "%48", "%49", "%4a", "%4b", "%4c", "%4d", "%4e", "%4f",

    "%50", "%51", "%52", "%53", "%54", "%55", "%56", "%57",

    "%58", "%59", "%5a", "%5b", "%5c", "%5d", "%5e", "%5f",

    "%60", "%61", "%62", "%63", "%64", "%65", "%66", "%67",

    "%68", "%69", "%6a", "%6b", "%6c", "%6d", "%6e", "%6f",

    "%70", "%71", "%72", "%73", "%74", "%75", "%76", "%77",

    "%78", "%79", "%7a", "%7b", "%7c", "%7d", "%7e", "%7f",

    "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",

    "%88", "%89", "%8a", "%8b", "%8c", "%8d", "%8e", "%8f",

    "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",

    "%98", "%99", "%9a", "%9b", "%9c", "%9d", "%9e", "%9f",

    "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%a7",

    "%a8", "%a9", "%aa", "%ab", "%ac", "%ad", "%ae", "%af",

    "%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7",

    "%b8", "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf",

    "%c0", "%c1", "%c2", "%c3", "%c4", "%c5", "%c6", "%c7",

    "%c8", "%c9", "%ca", "%cb", "%cc", "%cd", "%ce", "%cf",

    "%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",

    "%d8", "%d9", "%da", "%db", "%dc", "%dd", "%de", "%df",

    "%e0", "%e1", "%e2", "%e3", "%e4", "%e5", "%e6", "%e7",

    "%e8", "%e9", "%ea", "%eb", "%ec", "%ed", "%ee", "%ef",

    "%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",

    "%f8", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff"

    };

  private static boolean mRunning = false;

  private static int mMode = IDLE;

  private static Receiver mReceiver;

  private static Resources mResources;

  private static String mPackageName;

  private static String mScores = "";

  private static int[][][] mCountry = new int   [RubikObject.LENGTH][RubikStatePlay.MAX_SCRAMBLE][MAX_PLACES];

  private static String[][][] mName = new String[RubikObject.LENGTH][RubikStatePlay.MAX_SCRAMBLE][MAX_PLACES];

  private static String[][][] mTime = new String[RubikObject.LENGTH][RubikStatePlay.MAX_SCRAMBLE][MAX_PLACES];

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

  private void fillValues()

    {

    int begin=-1 ,end, len = mScores.length();

    while( begin<len )

      {

      end = mScores.indexOf('\n', begin+1);

      if( end<0 ) end = len;

      fillRow(mScores.substring(begin+1,end));

      begin = end;

      }

    }

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

  private void fillRow(String row)

    {

    int s1 = row.indexOf(' ');

    int s2 = row.indexOf(' ',s1+1);

    int s3 = row.indexOf(' ',s2+1);

    int s4 = row.indexOf(' ',s3+1);

    int s5 = row.indexOf(' ',s4+1);

    int s6 = row.length();

    if( s5>s4 && s4>s3 && s3>s2 && s2>s1 && s1>0 )

      {

      int size = Integer.valueOf( row.substring(0,s1) );

      if( size>=0 && size< RubikObject.LENGTH )

        {

        int level      = Integer.valueOf( row.substring(s1+1,s2) );

        int place      = Integer.valueOf( row.substring(s2+1,s3) );

        String name    = row.substring(s3+1, s4);

        int time       = Integer.valueOf( row.substring(s4+1,s5) );

        String country = row.substring(s5+1, s6);

        String realTime= String.valueOf(time/10.0f);

        if(level>=0 && level<RubikStatePlay.MAX_SCRAMBLE && place>=0 && place<MAX_PLACES)

          {

          int resID = mResources.getIdentifier( country, "drawable", mPackageName);

          mCountry[size][level][place] = resID!=0 ? resID: R.drawable.unk;

          mName[size][level][place]    = name;

          mTime[size][level][place]    = realTime;

          }

        }

      }

    }

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

  private String URLencode(String s)

    {

    StringBuilder sbuf = new StringBuilder();

    int len = s.length();

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

      {

      int ch = s.charAt(i);

           if ('A' <= ch && ch <= 'Z') sbuf.append((char)ch);

      else if ('a' <= ch && ch <= 'z') sbuf.append((char)ch);

      else if ('0' <= ch && ch <= '9') sbuf.append((char)ch);

      else if (ch == ' '             ) sbuf.append('+');

      else if (ch == '-' || ch == '_'

            || ch == '.' || ch == '!'

            || ch == '~' || ch == '*'

            || ch == '\'' || ch == '('

            || ch == ')'             ) sbuf.append((char)ch);

      else if (ch <= 0x007f)           sbuf.append(hex[ch]);

      else if (ch <= 0x07FF)

        {

        sbuf.append(hex[0xc0 | (ch >> 6)]);

        sbuf.append(hex[0x80 | (ch & 0x3F)]);

        }

      else

        {

        sbuf.append(hex[0xe0 | (ch >> 12)]);

        sbuf.append(hex[0x80 | ((ch >> 6) & 0x3F)]);

        sbuf.append(hex[0x80 | (ch & 0x3F)]);

        }

      }

    return sbuf.toString();

    }

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

  private boolean doDownload()

    {

    String veri = "distored";

    String name = URLencode(veri);

    int numRuns = 1;

    String version = R.string.app_version+"d";

    String message=URL+"/download.cgi?n="+name+"&r="+numRuns+"&e="+version;

    try

      {

      java.net.URL connectURL = new URL(message);

      HttpURLConnection conn = (HttpURLConnection)connectURL.openConnection();

      conn.setDoInput(true);

      conn.setDoOutput(true);

      conn.setUseCaches(false);

      conn.setRequestMethod("GET");

      conn.connect();

      conn.getOutputStream().flush();

      try( InputStream is = conn.getInputStream() )

        {

        int ch;

        StringBuilder sb = new StringBuilder();

        while( ( ch = is.read() ) != -1 )

          {

          sb.append( (char)ch );

          }

        mScores = sb.toString();

        }

      catch( final Exception e)

        {

        mReceiver.exception("Failed to get an answer from the High Scores server");

        return false;

        }

      }

    catch( final UnknownHostException e )

      {

      mReceiver.exception("No access to Internet");

      return false;

      }

    catch( final SecurityException e )

      {

      mReceiver.exception("Application not authorized to connect to the Internet");

      return false;

      }

    catch( final Exception e )

      {

      mReceiver.exception(e.getMessage());

      return false;

      }

    return true;

    }

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

  private boolean gottaDownload()

    {

    return ((mScores.length()==0) && !mRunning);

    }

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

  @Override

  public void run()

    {

    boolean success=true;

    try

      {

      if( gottaDownload() )

        {

        mRunning = true;

        success = doDownload();

        fillValues();

        }

      }

    catch( Exception e )

      {

      mReceiver.exception("Exception downloading records: "+e.getMessage() );

      }

    mRunning = false;

    if( success )

      {

      mReceiver.receive(mCountry, mName, mTime);

      }

    }

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

// PUBLIC API

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

  public static void onPause()

    {

    mRunning = false;

    }

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

  public void download(Receiver receiver, Resources resources, String packageName)

    {

    mReceiver = receiver;

    mResources= resources;

    mPackageName = packageName;

    mMode = DOWNLOAD;

    Thread networkThrd = new Thread(this);

    networkThrd.start();

    }

}

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

// 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.object;

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

import org.distorted.magic.R;

public enum RubikObject

  {

  CUBE2 ( 2, R.drawable.button2 ),

  CUBE3 ( 3, R.drawable.button3 ),

  CUBE4 ( 4, R.drawable.button4 ),

  CUBE5 ( 5, R.drawable.button5 ),

  ;

  public static final int LENGTH = values().length;

  private final int mObjectSize, mIconID;

  private static final RubikObject[] objects;

  static

    {

    int i = 0;

    objects = new RubikObject[LENGTH];

    for(RubikObject size: RubikObject.values())

      {

      objects[i] = size;

      i++;

      }

    }

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

  public static RubikObject getObject(int ordinal)

    {

    return objects[ordinal];

    }

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

  RubikObject(int size, int iconID)

    {

    mObjectSize = size;

    mIconID     = iconID;

    }

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

  public int getIconID()

    {

    return mIconID;

    }

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

  public int getObjectSize()

    {

    return mObjectSize;

    }

  }

import org.distorted.object.RubikObject;

  private int mButton = RubikObject.CUBE3.ordinal();

    for(int i = 0; i< RubikObject.LENGTH; i++)

      int iconID = RubikObject.getObject(i).getIconID();

    for(int b = 0; b< RubikObject.LENGTH; b++)