Project

General

Profile

Download (16.9 KB) Statistics
| Branch: | Tag: | Revision:

magiccube / src / main / java / org / distorted / objects / TwistyCube.java @ 925ed78f

1 0c52af30 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
2
// Copyright 2019 Leszek Koltunski                                                               //
3
//                                                                                               //
4 fdec60a3 Leszek Koltunski
// This file is part of Magic Cube.                                                              //
5 0c52af30 Leszek Koltunski
//                                                                                               //
6 fdec60a3 Leszek Koltunski
// Magic Cube is free software: you can redistribute it and/or modify                            //
7 0c52af30 Leszek Koltunski
// it under the terms of the GNU General Public License as published by                          //
8
// the Free Software Foundation, either version 2 of the License, or                             //
9
// (at your option) any later version.                                                           //
10
//                                                                                               //
11 fdec60a3 Leszek Koltunski
// Magic Cube is distributed in the hope that it will be useful,                                 //
12 0c52af30 Leszek Koltunski
// but WITHOUT ANY WARRANTY; without even the implied warranty of                                //
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                                 //
14
// GNU General Public License for more details.                                                  //
15
//                                                                                               //
16
// You should have received a copy of the GNU General Public License                             //
17 fdec60a3 Leszek Koltunski
// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //
18 0c52af30 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
19
20 1f9772f3 Leszek Koltunski
package org.distorted.objects;
21 0c52af30 Leszek Koltunski
22 ccf9fec5 Leszek Koltunski
import android.content.res.Resources;
23 0c52af30 Leszek Koltunski
import android.graphics.Canvas;
24
import android.graphics.Paint;
25
26 749ef882 Leszek Koltunski
import org.distorted.helpers.FactoryCubit;
27
import org.distorted.helpers.FactorySticker;
28 0c52af30 Leszek Koltunski
import org.distorted.library.main.DistortedEffects;
29
import org.distorted.library.main.DistortedTexture;
30 b32444ee Leszek Koltunski
import org.distorted.library.mesh.MeshBase;
31 efa8aa48 Leszek Koltunski
import org.distorted.library.mesh.MeshSquare;
32 0c52af30 Leszek Koltunski
import org.distorted.library.type.Static3D;
33
import org.distorted.library.type.Static4D;
34 6fd4a72c Leszek Koltunski
import org.distorted.main.R;
35 0c52af30 Leszek Koltunski
36 7c969a6d Leszek Koltunski
import java.util.Random;
37
38 0c52af30 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
39
40 9c2f0c91 Leszek Koltunski
class TwistyCube extends TwistyObject
41 0c52af30 Leszek Koltunski
{
42 e844c116 Leszek Koltunski
  // the three rotation axis of a RubikCube. Must be normalized.
43 ad38d800 Leszek Koltunski
  static final Static3D[] ROT_AXIS = new Static3D[]
44 efef689c Leszek Koltunski
         {
45
           new Static3D(1,0,0),
46
           new Static3D(0,1,0),
47
           new Static3D(0,0,1)
48
         };
49
50 925ed78f Leszek Koltunski
  private static final int[] BASIC_ANGLE = new int[] { 4,4,4 };
51
52 37a25788 Leszek Koltunski
  private static final int[] FACE_COLORS = new int[]
53 efef689c Leszek Koltunski
         {
54 ece1b58d Leszek Koltunski
           COLOR_YELLOW, COLOR_WHITE,
55
           COLOR_BLUE  , COLOR_GREEN,
56 323b217c Leszek Koltunski
           COLOR_RED   , COLOR_ORANGE
57 efef689c Leszek Koltunski
         };
58
59 10585385 Leszek Koltunski
  // All legal rotation quats of a RubikCube of any size.
60 efef689c Leszek Koltunski
  // Here's how to compute this:
61
  // 1) compute how many rotations there are (RubikCube of any size = 24)
62
  // 2) take the AXIS, angles of rotation (90 in RubikCube's case) compute the basic quaternions
63
  // (i.e. rotations of 1 basic angle along each of the axis) and from there start semi-randomly
64
  // multiplying them and eventually you'll find all (24) legal rotations.
65 9f4c44fe Leszek Koltunski
  // Example program in C, res/raw/compute_quats.c , is included.
66 10585385 Leszek Koltunski
  private static final Static4D[] QUATS = new Static4D[]
67 efef689c Leszek Koltunski
         {
68 10585385 Leszek Koltunski
         new Static4D(  0.0f,   0.0f,   0.0f,   1.0f),
69
         new Static4D(  1.0f,   0.0f,   0.0f,   0.0f),
70
         new Static4D(  0.0f,   1.0f,   0.0f,   0.0f),
71
         new Static4D(  0.0f,   0.0f,   1.0f,   0.0f),
72
73
         new Static4D( SQ2/2,  SQ2/2,  0.0f ,   0.0f),
74
         new Static4D( SQ2/2, -SQ2/2,  0.0f ,   0.0f),
75
         new Static4D( SQ2/2,   0.0f,  SQ2/2,   0.0f),
76
         new Static4D(-SQ2/2,   0.0f,  SQ2/2,   0.0f),
77
         new Static4D( SQ2/2,   0.0f,   0.0f,  SQ2/2),
78
         new Static4D( SQ2/2,   0.0f,   0.0f, -SQ2/2),
79
         new Static4D(  0.0f,  SQ2/2,  SQ2/2,   0.0f),
80
         new Static4D(  0.0f,  SQ2/2, -SQ2/2,   0.0f),
81
         new Static4D(  0.0f,  SQ2/2,   0.0f,  SQ2/2),
82
         new Static4D(  0.0f,  SQ2/2,   0.0f, -SQ2/2),
83
         new Static4D(  0.0f,   0.0f,  SQ2/2,  SQ2/2),
84
         new Static4D(  0.0f,   0.0f,  SQ2/2, -SQ2/2),
85
86
         new Static4D(  0.5f,   0.5f,   0.5f,   0.5f),
87
         new Static4D(  0.5f,   0.5f,  -0.5f,   0.5f),
88
         new Static4D(  0.5f,   0.5f,  -0.5f,  -0.5f),
89
         new Static4D(  0.5f,  -0.5f,   0.5f,  -0.5f),
90
         new Static4D( -0.5f,  -0.5f,  -0.5f,   0.5f),
91
         new Static4D( -0.5f,   0.5f,  -0.5f,  -0.5f),
92
         new Static4D( -0.5f,   0.5f,   0.5f,  -0.5f),
93
         new Static4D( -0.5f,   0.5f,   0.5f,   0.5f)
94 efef689c Leszek Koltunski
         };
95 411c6285 Leszek Koltunski
96 b1f2ccf5 Leszek Koltunski
  private static final double[][] VERTICES = new double[][]
97
          {
98
              { 0.5, 0.5, 0.5 },
99
              { 0.5, 0.5,-0.5 },
100
              { 0.5,-0.5, 0.5 },
101
              { 0.5,-0.5,-0.5 },
102
              {-0.5, 0.5, 0.5 },
103
              {-0.5, 0.5,-0.5 },
104
              {-0.5,-0.5, 0.5 },
105
              {-0.5,-0.5,-0.5 },
106
          };
107
108
  private static final int[][] VERT_INDEXES = new int[][]
109
          {
110
              {2,3,1,0},   // counterclockwise!
111
              {7,6,4,5},
112
              {4,0,1,5},
113
              {7,3,2,6},
114
              {6,2,0,4},
115
              {3,7,5,1}
116
          };
117
118
  private static final float[][] STICKERS = new float[][]
119
          {
120
              { -0.5f, -0.5f, 0.5f, -0.5f, 0.5f, 0.5f, -0.5f, 0.5f }
121
          };
122
123 fbca0033 Leszek Koltunski
  private static MeshBase[] mMeshes;
124 40ab026e Leszek Koltunski
125 411c6285 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
126
127 9c2f0c91 Leszek Koltunski
  TwistyCube(int size, Static4D quat, DistortedTexture texture,
128
             MeshSquare mesh, DistortedEffects effects, int[][] moves, Resources res, int scrWidth)
129 411c6285 Leszek Koltunski
    {
130 db875721 Leszek Koltunski
    super(size, size, quat, texture, mesh, effects, moves, ObjectList.CUBE, res, scrWidth);
131 411c6285 Leszek Koltunski
    }
132
133 ac940e24 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
134
135 a64e07d0 Leszek Koltunski
  MeshBase createCubitMesh(int cubit, int numLayers)
136 ac940e24 Leszek Koltunski
    {
137
    if( mMeshes==null )
138
      {
139 b1f2ccf5 Leszek Koltunski
      FactoryCubit factory = FactoryCubit.getInstance();
140
      factory.clear();
141 ac940e24 Leszek Koltunski
      mMeshes = new MeshBase[ObjectList.CUBE.getNumVariants()];
142
      }
143
144
    int ordinal= ObjectList.CUBE.ordinal();
145 d99f3a48 Leszek Koltunski
    int index  = ObjectList.getSizeIndex(ordinal,getNumLayers());
146 ac940e24 Leszek Koltunski
147
    if( mMeshes[index]==null )
148
      {
149 b1f2ccf5 Leszek Koltunski
      int extraI, extraV, num;
150 67b2d57b Leszek Koltunski
      float height;
151 b1f2ccf5 Leszek Koltunski
152
      switch(numLayers)
153
        {
154 67b2d57b Leszek Koltunski
        case 2 : num = 6; extraI = 2; extraV = 2; height = 0.045f; break;
155
        case 3 : num = 5; extraI = 2; extraV = 2; height = 0.045f; break;
156
        case 4 : num = 5; extraI = 1; extraV = 1; height = 0.045f; break;
157
        default: num = 5; extraI = 0; extraV = 0; height = 0.045f; break;
158 b1f2ccf5 Leszek Koltunski
        }
159
160 67b2d57b Leszek Koltunski
      float[][] bands     = new float[][] { {height,35,0.5f,0.7f,num,extraI,extraV} };
161 b1f2ccf5 Leszek Koltunski
      int[] bandIndexes   = new int[] { 0,0,0,0,0,0};
162
      float[][] corners   = new float[][] { {0.036f,0.12f} };
163
      int[] cornerIndexes = new int[] { 0,0,0,0,0,0,0,0 };
164 b3c9061a Leszek Koltunski
      float[][] centers   = new float[][] { {0.0f, 0.0f, 0.0f} };
165
      int[] centerIndexes = new int[] { 0,0,0,0,0,0,0,0 };
166 b1f2ccf5 Leszek Koltunski
167
      FactoryCubit factory = FactoryCubit.getInstance();
168
169
      factory.createNewFaceTransform(VERTICES,VERT_INDEXES);
170
      mMeshes[index] = factory.createRoundedSolid(VERTICES, VERT_INDEXES,
171
                                                  bands, bandIndexes,
172
                                                  corners, cornerIndexes,
173 b3c9061a Leszek Koltunski
                                                  centers, centerIndexes,
174 b1f2ccf5 Leszek Koltunski
                                                  getNumCubitFaces() );
175 ac940e24 Leszek Koltunski
      }
176
177
    return mMeshes[index].copy(true);
178
    }
179
180 7289fd6c Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
181
182 ae755eda Leszek Koltunski
  void createFaceTexture(Canvas canvas, Paint paint, int face, int left, int top)
183 7289fd6c Leszek Koltunski
    {
184 76c2bd07 Leszek Koltunski
    float R = 0.10f;
185 2fcfce81 Leszek Koltunski
    float S = 0.08f;
186 7289fd6c Leszek Koltunski
187 b89898c5 Leszek Koltunski
    FactorySticker factory = FactorySticker.getInstance();
188 b1f2ccf5 Leszek Koltunski
    factory.drawRoundedPolygon(canvas, paint, left, top, STICKERS[0], S, FACE_COLORS[face], R);
189 7289fd6c Leszek Koltunski
    }
190
191 411c6285 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
192
193 b1f2ccf5 Leszek Koltunski
  float[][] getCubitPositions(int numLayers)
194 a10ada2a Leszek Koltunski
    {
195 b1f2ccf5 Leszek Koltunski
    int numCubits = numLayers>1 ? 6*numLayers*numLayers - 12*numLayers + 8 : 1;
196 e6cf7283 Leszek Koltunski
    float[][] tmp = new float[numCubits][];
197 beb325a0 Leszek Koltunski
198 b1f2ccf5 Leszek Koltunski
    float diff = 0.5f*(numLayers-1);
199 a10ada2a Leszek Koltunski
    int currentPosition = 0;
200 beb325a0 Leszek Koltunski
201 b1f2ccf5 Leszek Koltunski
    for(int x = 0; x<numLayers; x++)
202
      for(int y = 0; y<numLayers; y++)
203
        for(int z = 0; z<numLayers; z++)
204
          if( x==0 || x==numLayers-1 || y==0 || y==numLayers-1 || z==0 || z==numLayers-1 )
205 beb325a0 Leszek Koltunski
            {
206 e6cf7283 Leszek Koltunski
            tmp[currentPosition++] = new float[] {x-diff,y-diff,z-diff};
207 a10ada2a Leszek Koltunski
            }
208 47ba5ddc Leszek Koltunski
209 a10ada2a Leszek Koltunski
    return tmp;
210
    }
211 47ba5ddc Leszek Koltunski
212 beb325a0 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
213
214 10585385 Leszek Koltunski
  Static4D[] getQuats()
215 a10ada2a Leszek Koltunski
    {
216 10585385 Leszek Koltunski
    return QUATS;
217 a10ada2a Leszek Koltunski
    }
218 47ba5ddc Leszek Koltunski
219 eaee1ddc Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
220
221
  boolean shouldResetTextureMaps()
222
    {
223
    return false;
224
    }
225
226 47ba5ddc Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
227
228 411c6285 Leszek Koltunski
  int getNumFaces()
229 a10ada2a Leszek Koltunski
    {
230 411c6285 Leszek Koltunski
    return FACE_COLORS.length;
231 8f53e513 Leszek Koltunski
    }
232
233 7403cdfa Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
234
235 a64e07d0 Leszek Koltunski
  float[] getCuts(int numLayers)
236 7403cdfa Leszek Koltunski
    {
237 a64e07d0 Leszek Koltunski
    float[] cuts = new float[numLayers-1];
238 a97e02b7 Leszek Koltunski
239 a64e07d0 Leszek Koltunski
    for(int i=0; i<numLayers-1; i++)
240 a97e02b7 Leszek Koltunski
      {
241 a64e07d0 Leszek Koltunski
      cuts[i] = (2-numLayers)*0.5f + i;
242 a97e02b7 Leszek Koltunski
      }
243
244
    return cuts;
245 7403cdfa Leszek Koltunski
    }
246
247 eab9d8f8 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
248
249 a64e07d0 Leszek Koltunski
  int getNumStickerTypes(int numLayers)
250 eab9d8f8 Leszek Koltunski
    {
251 b1f2ccf5 Leszek Koltunski
    return STICKERS.length;
252 eab9d8f8 Leszek Koltunski
    }
253
254 8f53e513 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
255
256
  int getNumCubitFaces()
257
    {
258
    return FACE_COLORS.length;
259 411c6285 Leszek Koltunski
    }
260 47ba5ddc Leszek Koltunski
261 f0fa83ae Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
262
263
  float getScreenRatio()
264
    {
265
    return 0.5f;
266
    }
267
268 f6d06256 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
269
270
  int getFaceColor(int cubit, int cubitface, int size)
271
    {
272 2ef489e2 Leszek Koltunski
    return CUBITS[cubit].mRotationRow[cubitface/2] == (cubitface%2==0 ? (1<<(size-1)):1) ? cubitface : NUM_FACES;
273 f6d06256 Leszek Koltunski
    }
274
275 fb377dae Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
276
277
  float returnMultiplier()
278
    {
279 d99f3a48 Leszek Koltunski
    return getNumLayers();
280 fb377dae Leszek Koltunski
    }
281
282 e844c116 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
283
// PUBLIC API
284
285 12ad3fca Leszek Koltunski
  public Static3D[] getRotationAxis()
286
    {
287 ad38d800 Leszek Koltunski
    return ROT_AXIS;
288 12ad3fca Leszek Koltunski
    }
289
290
///////////////////////////////////////////////////////////////////////////////////////////////////
291
292 925ed78f Leszek Koltunski
  public int[] getBasicAngle()
293 e844c116 Leszek Koltunski
    {
294 925ed78f Leszek Koltunski
    return BASIC_ANGLE;
295 e844c116 Leszek Koltunski
    }
296 39e74052 Leszek Koltunski
297 7c969a6d Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
298
299 5043d5d0 Leszek Koltunski
  public void randomizeNewScramble(int[][] scramble, Random rnd, int num)
300 7c969a6d Leszek Koltunski
    {
301 5043d5d0 Leszek Koltunski
    if( num==0 )
302 5cf34c5f Leszek Koltunski
      {
303 582617c1 Leszek Koltunski
      scramble[num][0] = rnd.nextInt(NUM_AXIS);
304 7c969a6d Leszek Koltunski
      }
305
    else
306
      {
307 582617c1 Leszek Koltunski
      int newVector = rnd.nextInt(NUM_AXIS -1);
308 5043d5d0 Leszek Koltunski
      scramble[num][0] = (newVector>=scramble[num-1][0] ? newVector+1 : newVector);
309 5cf34c5f Leszek Koltunski
      }
310
311 7c969a6d Leszek Koltunski
    float rowFloat = rnd.nextFloat();
312 0203be88 Leszek Koltunski
    int numLayers = getNumLayers();
313 7c969a6d Leszek Koltunski
314 0203be88 Leszek Koltunski
    for(int row=0; row<numLayers; row++)
315 7c969a6d Leszek Koltunski
      {
316 0203be88 Leszek Koltunski
      if( rowFloat*numLayers <= row+1 )
317 bbc6471c Leszek Koltunski
        {
318 5043d5d0 Leszek Koltunski
        scramble[num][1] = row;
319 bbc6471c Leszek Koltunski
        break;
320
        }
321 7c969a6d Leszek Koltunski
      }
322
323 5043d5d0 Leszek Koltunski
    switch( rnd.nextInt(4) )
324
      {
325
      case 0: scramble[num][2] = -2; break;
326
      case 1: scramble[num][2] = -1; break;
327
      case 2: scramble[num][2] =  1; break;
328
      case 3: scramble[num][2] =  2; break;
329
      }
330 e46e17fb Leszek Koltunski
    }
331 f0336037 Leszek Koltunski
332 6b6504fe Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
333
334
  public boolean isSolved()
335
    {
336
    int index = CUBITS[0].mQuatIndex;
337
338
    for(int i=1; i<NUM_CUBITS; i++)
339
      {
340 722b2512 Leszek Koltunski
      if( thereIsVisibleDifference(CUBITS[i], index) ) return false;
341 6b6504fe Leszek Koltunski
      }
342
343
    return true;
344
    }
345
346 f0336037 Leszek Koltunski
///////////////////////////////////////////////////////////////////////////////////////////////////
347 a304ee64 Leszek Koltunski
// order: Up --> Right --> Front --> Down --> Left --> Back
348
// (because the first implemented Solver - the two-phase Cube3 one - expects such order)
349
//
350 fa0f7a56 Leszek Koltunski
// Solved 3x3x3 Cube maps to "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB"
351 a304ee64 Leszek Koltunski
//
352 fa0f7a56 Leszek Koltunski
// s : size of the cube; let index = a*s + b    (i.e. a,b = row,column)
353
//
354
// Up    :   index --> b<s-1 ? (s-1)*(s+4b)+a : 6*s*s -13*s +8 +a
355 a304ee64 Leszek Koltunski
// Right :   index --> 6*s*s - 12*s + 7 - index
356 fa0f7a56 Leszek Koltunski
// Front :   index --> if b==0  : s*s - 1 - index
357
//                     if b==s-1: 6*s*s -11*s +6 - index
358
//                     else
359
//                         a==0: s*s + s-1 + 4*(b-1)*(s-1) + 2*(s-2) + s
360
//                         else: s*s + s-1 + 4*(b-1)*(s-1) + 2*(s-1-a)
361
// Down  :   index --> b==0 ? (s-1-a) : s*s + s-1 + 4*(b-1)*(s-1) - a
362
// Left  :   index --> (s-1-a)*s + b
363
// Back  :   index --> if b==s-1: s*(s-1-a)
364
//                     if b==0  : 5*s*s -12*s + 8 + (s-1-a)*s
365
//                     else
366
//                        if a==s-1: s*s + 4*(s-2-b)*(s-1)
367
//                        else     : s*s + 4*(s-2-b)*(s-1) + s + (s-2-a)*2
368 f0336037 Leszek Koltunski
369 20931cf6 Leszek Koltunski
  public String retObjectString()
370 f0336037 Leszek Koltunski
    {
371 fa0f7a56 Leszek Koltunski
    StringBuilder objectString = new StringBuilder();
372 d99f3a48 Leszek Koltunski
    int layers = getNumLayers();
373
    int len = layers*layers;
374 ac940e24 Leszek Koltunski
    int cubitIndex, row, col, color,face;
375 fa0f7a56 Leszek Koltunski
376
    final int RIGHT= 0;
377
    final int LEFT = 1;
378
    final int UP   = 2;
379
    final int DOWN = 3;
380
    final int FRONT= 4;
381
    final int BACK = 5;
382
383 fb52fae9 Leszek Koltunski
    // 'I' - interior, theoretically can happen
384
    final char[] FACE_NAMES = { 'R', 'L', 'U', 'D', 'F', 'B', 'I'};
385 49595e4b Leszek Koltunski
386
    face = UP;
387
388 fa0f7a56 Leszek Koltunski
    for(int i=0; i<len; i++)
389
      {
390 d99f3a48 Leszek Koltunski
      row = i/layers;
391
      col = i%layers;
392 fa0f7a56 Leszek Koltunski
393 d99f3a48 Leszek Koltunski
      cubitIndex = col<layers-1 ? (layers-1)*(layers+4*col) + row : 6*layers*layers - 13*layers + 8 + row;
394 49595e4b Leszek Koltunski
      color = getCubitFaceColorIndex(cubitIndex,face);
395 fa0f7a56 Leszek Koltunski
      objectString.append(FACE_NAMES[color]);
396
      }
397
398 49595e4b Leszek Koltunski
    face = RIGHT;
399
400 fa0f7a56 Leszek Koltunski
    for(int i=0; i<len; i++)
401
      {
402 d99f3a48 Leszek Koltunski
      cubitIndex = 6*layers*layers - 12*layers +7 - i;
403 49595e4b Leszek Koltunski
      color = getCubitFaceColorIndex(cubitIndex,face);
404 fa0f7a56 Leszek Koltunski
      objectString.append(FACE_NAMES[color]);
405
      }
406
407 064ccc31 Leszek Koltunski
    face = FRONT;
408 49595e4b Leszek Koltunski
409 fa0f7a56 Leszek Koltunski
    for(int i=0; i<len; i++)
410
      {
411 d99f3a48 Leszek Koltunski
      row = i/layers;
412
      col = i%layers;
413 fa0f7a56 Leszek Koltunski
414 d99f3a48 Leszek Koltunski
      if( col==layers-1 ) cubitIndex = 6*layers*layers - 11*layers + 6 -i;
415
      else if(   col==0 ) cubitIndex = layers*layers - 1 - i;
416 fa0f7a56 Leszek Koltunski
      else
417
        {
418 d99f3a48 Leszek Koltunski
        if( row==0 ) cubitIndex = layers*layers + layers-1 + 4*(col-1)*(layers-1) + 2*(layers-2) + layers;
419
        else         cubitIndex = layers*layers + layers-1 + 4*(col-1)*(layers-1) + 2*(layers-1-row);
420 fa0f7a56 Leszek Koltunski
        }
421
422 49595e4b Leszek Koltunski
      color = getCubitFaceColorIndex(cubitIndex,face);
423 fa0f7a56 Leszek Koltunski
      objectString.append(FACE_NAMES[color]);
424
      }
425
426 49595e4b Leszek Koltunski
    face = DOWN;
427
428 fa0f7a56 Leszek Koltunski
    for(int i=0; i<len; i++)
429
      {
430 d99f3a48 Leszek Koltunski
      row = i/layers;
431
      col = i%layers;
432 fa0f7a56 Leszek Koltunski
433 d99f3a48 Leszek Koltunski
      cubitIndex = col==0 ? layers-1-row : layers*layers + layers-1 + 4*(col-1)*(layers-1) - row;
434 49595e4b Leszek Koltunski
      color = getCubitFaceColorIndex(cubitIndex,face);
435 fa0f7a56 Leszek Koltunski
      objectString.append(FACE_NAMES[color]);
436
      }
437
438 49595e4b Leszek Koltunski
    face = LEFT;
439
440 fa0f7a56 Leszek Koltunski
    for(int i=0; i<len; i++)
441
      {
442 d99f3a48 Leszek Koltunski
      row = i/layers;
443
      col = i%layers;
444 fa0f7a56 Leszek Koltunski
445 d99f3a48 Leszek Koltunski
      cubitIndex = (layers-1-row)*layers + col;
446 49595e4b Leszek Koltunski
      color = getCubitFaceColorIndex(cubitIndex,face);
447 fa0f7a56 Leszek Koltunski
      objectString.append(FACE_NAMES[color]);
448
      }
449
450 49595e4b Leszek Koltunski
    face = BACK;
451
452 fa0f7a56 Leszek Koltunski
    for(int i=0; i<len; i++)
453
      {
454 d99f3a48 Leszek Koltunski
      row = i/layers;
455
      col = i%layers;
456 fa0f7a56 Leszek Koltunski
457 d99f3a48 Leszek Koltunski
      if( col==layers-1 ) cubitIndex = layers*(layers-1-row);
458
      else if(   col==0 ) cubitIndex = 5*layers*layers - 12*layers + 8 + (layers-1-row)*layers;
459 fa0f7a56 Leszek Koltunski
      else
460
        {
461 d99f3a48 Leszek Koltunski
        if( row==layers-1 ) cubitIndex = layers*layers + 4*(layers-2-col)*(layers-1);
462
        else                cubitIndex = layers*layers + 4*(layers-2-col)*(layers-1) + layers + 2*(layers-2-row);
463 fa0f7a56 Leszek Koltunski
        }
464
465 49595e4b Leszek Koltunski
      color = getCubitFaceColorIndex(cubitIndex,face);
466 fa0f7a56 Leszek Koltunski
      objectString.append(FACE_NAMES[color]);
467
      }
468
469
    return objectString.toString();
470 f0336037 Leszek Koltunski
    }
471 6fd4a72c Leszek Koltunski
472
///////////////////////////////////////////////////////////////////////////////////////////////////
473
474
  public int getObjectName(int numLayers)
475
    {
476
    switch(numLayers)
477
      {
478
      case 2: return R.string.cube2;
479
      case 3: return R.string.cube3;
480
      case 4: return R.string.cube4;
481
      case 5: return R.string.cube5;
482
      }
483
    return R.string.cube3;
484
    }
485
486
///////////////////////////////////////////////////////////////////////////////////////////////////
487
488
  public int getInventor(int numLayers)
489
    {
490
    switch(numLayers)
491
      {
492
      case 2: return R.string.cube2_inventor;
493
      case 3: return R.string.cube3_inventor;
494
      case 4: return R.string.cube4_inventor;
495
      case 5: return R.string.cube5_inventor;
496
      }
497
    return R.string.cube3_inventor;
498
    }
499
500
///////////////////////////////////////////////////////////////////////////////////////////////////
501
502
  public int getComplexity(int numLayers)
503
    {
504
    switch(numLayers)
505
      {
506
      case 2: return 4;
507
      case 3: return 6;
508
      case 4: return 8;
509
      case 5: return 10;
510
      }
511
    return 6;
512
    }
513 0c52af30 Leszek Koltunski
}