Project

General

Profile

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

magiccube / src / main / java / org / distorted / objects / ObjectList.java @ 516451c4

1
///////////////////////////////////////////////////////////////////////////////////////////////////
2
// Copyright 2020 Leszek Koltunski                                                               //
3
//                                                                                               //
4
// This file is part of Magic Cube.                                                              //
5
//                                                                                               //
6
// Magic Cube is free software: you can redistribute it and/or modify                            //
7
// 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
// Magic Cube is distributed in the hope that it will be useful,                                 //
12
// 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
// along with Magic Cube.  If not, see <http://www.gnu.org/licenses/>.                           //
18
///////////////////////////////////////////////////////////////////////////////////////////////////
19

    
20
package org.distorted.objects;
21

    
22
import android.content.res.Resources;
23

    
24
import org.distorted.library.main.DistortedEffects;
25
import org.distorted.library.main.DistortedTexture;
26
import org.distorted.library.mesh.MeshSquare;
27
import org.distorted.library.type.Static4D;
28
import org.distorted.main.R;
29
import org.distorted.main.RubikActivity;
30

    
31
import java.lang.reflect.Field;
32

    
33
///////////////////////////////////////////////////////////////////////////////////////////////////
34

    
35
public enum ObjectList
36
  {
37
  ///////////////////// Size // DB Level // NumScrambles // Mesh // small icon // medium icon // big icon // huge icon
38

    
39
  CUBE (
40
         new int[][] {
41
                       {2 , 12, 12, R.raw.cube2, R.drawable.ui_small_cube2, R.drawable.ui_medium_cube2, R.drawable.ui_big_cube2, R.drawable.ui_huge_cube2} ,
42
                       {3 , 16, 17, R.raw.cube3, R.drawable.ui_small_cube3, R.drawable.ui_medium_cube3, R.drawable.ui_big_cube3, R.drawable.ui_huge_cube3} ,
43
                       {4 , 20, 24, R.raw.cube4, R.drawable.ui_small_cube4, R.drawable.ui_medium_cube4, R.drawable.ui_big_cube4, R.drawable.ui_huge_cube4} ,
44
                       {5 , 24, 28, R.raw.cube5, R.drawable.ui_small_cube5, R.drawable.ui_medium_cube5, R.drawable.ui_big_cube5, R.drawable.ui_huge_cube5}
45
                     },
46
         TwistyCube.class,
47
         new MovementCube(),
48
         0,
49
         60
50
       ),
51

    
52
  PYRA (
53
         new int[][] {
54
                       {3 , 10, 10, R.raw.pyra3, R.drawable.ui_small_pyra3, R.drawable.ui_medium_pyra3, R.drawable.ui_big_pyra3, R.drawable.ui_huge_pyra3} ,
55
                       {4 , 15, 17, R.raw.pyra4, R.drawable.ui_small_pyra4, R.drawable.ui_medium_pyra4, R.drawable.ui_big_pyra4, R.drawable.ui_huge_pyra4} ,
56
                       {5 , 20, 23, R.raw.pyra5, R.drawable.ui_small_pyra5, R.drawable.ui_medium_pyra5, R.drawable.ui_big_pyra5, R.drawable.ui_huge_pyra5}
57
                     },
58
         TwistyPyraminx.class,
59
         new MovementPyraminx(),
60
         1,
61
         30
62
       ),
63

    
64
  ULTI (
65
         new int[][] {
66
                       {2 , 18, 18, R.raw.ulti, R.drawable.ui_small_ulti, R.drawable.ui_medium_ulti, R.drawable.ui_big_ulti, R.drawable.ui_huge_ulti} ,
67
                     },
68
         TwistyUltimate.class,
69
         new MovementUltimate(),
70
         1,
71
         30
72
       ),
73

    
74
  KILO (
75
         new int[][] {
76
                       {3 , 18, 18, R.raw.kilo3, R.drawable.ui_small_kilo3, R.drawable.ui_medium_kilo3, R.drawable.ui_big_kilo3, R.drawable.ui_huge_kilo3} ,
77
                       {5 , 33, 33, R.raw.kilo5, R.drawable.ui_small_kilo5, R.drawable.ui_medium_kilo5, R.drawable.ui_big_kilo5, R.drawable.ui_huge_kilo5} ,
78
                     },
79
         TwistyKilominx.class,
80
         new MovementMinx(),
81
         2,
82
         30
83
       ),
84

    
85
  MEGA (
86
         new int[][] {
87
                       {3 , 21, 21, R.raw.mega3, R.drawable.ui_small_mega3, R.drawable.ui_medium_mega3, R.drawable.ui_big_mega3, R.drawable.ui_huge_mega3} ,
88
                       {5 , 35, 37, R.raw.mega5, R.drawable.ui_small_mega5, R.drawable.ui_medium_mega5, R.drawable.ui_big_mega5, R.drawable.ui_huge_mega5} ,
89
                     },
90
         TwistyMegaminx.class,
91
         new MovementMinx(),
92
         2,
93
         30
94
       ),
95

    
96
  DINO (
97
         new int[][] {
98
                       {3 , 10, 10, R.raw.dino, R.drawable.ui_small_dino, R.drawable.ui_medium_dino, R.drawable.ui_big_dino, R.drawable.ui_huge_dino} ,
99
                     },
100
         TwistyDino6.class,
101
         new MovementDino(),
102
         3,
103
         60
104
       ),
105

    
106
  DIN4 (
107
         new int[][] {
108
                       {3 , 7, 7, R.raw.dino, R.drawable.ui_small_din4, R.drawable.ui_medium_din4, R.drawable.ui_big_din4, R.drawable.ui_huge_din4} ,
109
                     },
110
         TwistyDino4.class,
111
         new MovementDino(),
112
         3,
113
         60
114
       ),
115

    
116
  REDI (
117
         new int[][] {
118
                       {3 , 14, 16, R.raw.redi, R.drawable.ui_small_redi, R.drawable.ui_medium_redi, R.drawable.ui_big_redi, R.drawable.ui_huge_redi} ,
119
                     },
120
         TwistyRedi.class,
121
         new MovementRedi(),
122
         3,
123
         60
124
       ),
125

    
126
  HELI (
127
         new int[][] {
128
                       {3 , 18, 20, R.raw.heli, R.drawable.ui_small_heli, R.drawable.ui_medium_heli, R.drawable.ui_big_heli, R.drawable.ui_huge_heli} ,
129
                     },
130
         TwistyHelicopter.class,
131
         new MovementHelicopter(),
132
         3,
133
         60
134
       ),
135

    
136
  SKEW (
137
         new int[][] {
138
                       {2 , 11, 11, R.raw.skew2, R.drawable.ui_small_skewb, R.drawable.ui_medium_skewb, R.drawable.ui_big_skewb, R.drawable.ui_huge_skewb} ,
139
                       {3 , 17, 21, R.raw.skew3, R.drawable.ui_small_skewm, R.drawable.ui_medium_skewm, R.drawable.ui_big_skewm, R.drawable.ui_huge_skewm} ,
140
                     },
141
         TwistySkewb.class,
142
         new MovementSkewb(),
143
         4,
144
         60
145
       ),
146

    
147
  IVY  (
148
         new int[][] {
149
                       {2 , 8, 8, R.raw.ivy, R.drawable.ui_small_ivy, R.drawable.ui_medium_ivy, R.drawable.ui_big_ivy, R.drawable.ui_huge_ivy} ,
150
                     },
151
         TwistyIvy.class,
152
         new MovementIvy(),
153
         4,
154
         60
155
       ),
156

    
157
  REX  (
158
         new int[][] {
159
                       {3 , 16, 19, R.raw.rex, R.drawable.ui_small_rex, R.drawable.ui_medium_rex, R.drawable.ui_big_rex, R.drawable.ui_huge_rex} ,
160
                     },
161
         TwistyRex.class,
162
         new MovementRex(),
163
         4,
164
         60
165
       ),
166

    
167
  BAN1 (
168
         new int[][] {
169
                       {3 , 16, 16, R.raw.ban1, R.drawable.ui_small_ban1, R.drawable.ui_medium_ban1, R.drawable.ui_big_ban1, R.drawable.ui_huge_ban1} ,
170
                     },
171
         TwistyBandagedFused.class,
172
         new MovementCube(),
173
         5,
174
         60
175
       ),
176

    
177
  BAN2 (
178
         new int[][] {
179
                       {3 , 16, 16, R.raw.ban2, R.drawable.ui_small_ban2, R.drawable.ui_medium_ban2, R.drawable.ui_big_ban2, R.drawable.ui_huge_ban2} ,
180
                     },
181
         TwistyBandaged2Bar.class,
182
         new MovementCube(),
183
         5,
184
         60
185
       ),
186

    
187
  BAN3 (
188
         new int[][] {
189
                       {3 , 16, 16, R.raw.ban3, R.drawable.ui_small_ban3, R.drawable.ui_medium_ban3, R.drawable.ui_big_ban3, R.drawable.ui_huge_ban3} ,
190
                     },
191
         TwistyBandaged3Plate.class,
192
         new MovementCube(),
193
         5,
194
         60
195
       ),
196

    
197
  BAN4 (
198
         new int[][] {
199
                       {3 , 16, 16, R.raw.ban4, R.drawable.ui_small_ban4, R.drawable.ui_medium_ban4, R.drawable.ui_big_ban4, R.drawable.ui_huge_ban4} ,
200
                     },
201
         TwistyBandagedEvil.class,
202
         new MovementCube(),
203
         5,
204
         60
205
       ),
206

    
207
  DIAM (
208
         new int[][] {
209
                       {2 , 10, 12, R.raw.diam2, R.drawable.ui_small_diam2, R.drawable.ui_medium_diam2, R.drawable.ui_big_diam2, R.drawable.ui_huge_diam2} ,
210
                       {3 , 18, 24, R.raw.diam3, R.drawable.ui_small_diam3, R.drawable.ui_medium_diam3, R.drawable.ui_big_diam3, R.drawable.ui_huge_diam3} ,
211
                     },
212
         TwistyDiamond.class,
213
         new MovementDiamond(),
214
         6,
215
         60
216
       ),
217

    
218
  SQU1 (
219
         new int[][] {
220
                       {3 , 24, 24, R.raw.square1, R.drawable.ui_small_square1, R.drawable.ui_medium_square1, R.drawable.ui_big_square1, R.drawable.ui_huge_square1} ,
221
                     },
222
         TwistySquare1.class,
223
         new MovementSquare(),
224
         6,
225
         60
226
       ),
227

    
228
  SQU2 (
229
         new int[][] {
230
                       {3 , 24, 24, R.raw.square2, R.drawable.ui_small_square2, R.drawable.ui_medium_square2, R.drawable.ui_big_square2, R.drawable.ui_huge_square2} ,
231
                     },
232
         TwistySquare2.class,
233
         new MovementSquare(),
234
         6,
235
         60
236
       ),
237
  ;
238

    
239
  public static final int NUM_OBJECTS = values().length;
240
  public static final int MAX_NUM_OBJECTS;
241
  public static final int MAX_LEVEL;
242
  public static final int MAX_SCRAMBLE;
243
  public static final int MAX_OBJECT_SIZE;
244

    
245
  private final int[] mObjectSizes, mDBLevels, mNumScrambles, mSmallIconIDs, mMediumIconIDs, mBigIconIDs, mHugeIconIDs, mResourceIDs;
246
  private final Class<? extends TwistyObject> mObjectClass;
247
  private final Movement mObjectMovementClass;
248
  private final int mRow, mNumSizes;
249
  private final int mFOV;
250

    
251
  private static final ObjectList[] objects;
252
  private static int mNumAll;
253
  private static int[] mIndices;
254
  private static int mColCount, mRowCount;
255

    
256
  static
257
    {
258
    mNumAll = 0;
259
    int num, i = 0;
260
    objects = new ObjectList[NUM_OBJECTS];
261
    int maxNum     = Integer.MIN_VALUE;
262
    int maxLevel   = Integer.MIN_VALUE;
263
    int maxScramble= Integer.MIN_VALUE;
264
    int maxSize    = Integer.MIN_VALUE;
265

    
266
    for(ObjectList object: ObjectList.values())
267
      {
268
      objects[i] = object;
269
      i++;
270
      num = object.mObjectSizes.length;
271
      mNumAll += num;
272
      if( num> maxNum ) maxNum = num;
273

    
274
      for(int j=0; j<num; j++)
275
        {
276
        if( object.mNumScrambles[j]> maxScramble ) maxScramble= object.mNumScrambles[j];
277
        if( object.mDBLevels[j]    > maxLevel    ) maxLevel   = object.mDBLevels[j];
278
        if( object.mObjectSizes[j] > maxSize     ) maxSize    = object.mObjectSizes[j];
279
        }
280
      }
281

    
282
    MAX_NUM_OBJECTS = maxNum;
283
    MAX_LEVEL       = maxLevel;
284
    MAX_SCRAMBLE    = maxScramble;
285
    MAX_OBJECT_SIZE = maxSize;
286
    }
287

    
288
///////////////////////////////////////////////////////////////////////////////////////////////////
289

    
290
  private static void setUpColAndRow()
291
    {
292
    mIndices = new int[NUM_OBJECTS];
293
    mRowCount= 0;
294

    
295
    for(int obj=0; obj<NUM_OBJECTS; obj++)
296
      {
297
      mIndices[obj] = objects[obj].mRow;
298
      if( mIndices[obj]>=mRowCount ) mRowCount = mIndices[obj]+1;
299
      }
300

    
301
    mColCount = 0;
302

    
303
    for(int row=0; row<mRowCount; row++)
304
      {
305
      int numObjects = computeNumObjectsInRow(row);
306
      if( numObjects>mColCount ) mColCount = numObjects;
307
      }
308
    }
309

    
310
///////////////////////////////////////////////////////////////////////////////////////////////////
311

    
312
  private static int computeNumObjectsInRow(int row)
313
    {
314
    int num=0;
315

    
316
    for(int object=0; object<NUM_OBJECTS; object++)
317
      {
318
      if( objects[object].mRow == row )
319
        {
320
        num += objects[object].mNumSizes;
321
        }
322
      }
323

    
324
    return num;
325
    }
326

    
327
///////////////////////////////////////////////////////////////////////////////////////////////////
328

    
329
  public static int getColumnCount()
330
    {
331
    if( mIndices==null ) setUpColAndRow();
332

    
333
    return mColCount;
334
    }
335

    
336
///////////////////////////////////////////////////////////////////////////////////////////////////
337

    
338
  public static int getRowCount()
339
    {
340
    if( mIndices==null ) setUpColAndRow();
341

    
342
    return mRowCount;
343
    }
344

    
345
///////////////////////////////////////////////////////////////////////////////////////////////////
346

    
347
  public static int[] getIndices()
348
    {
349
    if( mIndices==null ) setUpColAndRow();
350

    
351
    return mIndices;
352
    }
353

    
354
///////////////////////////////////////////////////////////////////////////////////////////////////
355

    
356
  public static ObjectList getObject(int ordinal)
357
    {
358
    return ordinal>=0 && ordinal<NUM_OBJECTS ? objects[ordinal] : CUBE;
359
    }
360

    
361
///////////////////////////////////////////////////////////////////////////////////////////////////
362

    
363
  public static int pack(int object, int sizeIndex)
364
    {
365
    int ret = 0;
366
    for(int i=0; i<object; i++) ret += objects[i].mObjectSizes.length;
367

    
368
    return ret+sizeIndex;
369
    }
370

    
371
///////////////////////////////////////////////////////////////////////////////////////////////////
372

    
373
  public static int unpackSizeIndex(int number)
374
    {
375
    int num;
376

    
377
    for(int i=0; i<NUM_OBJECTS; i++)
378
      {
379
      num = objects[i].mObjectSizes.length;
380
      if( number<num ) return number;
381
      number -= num;
382
      }
383

    
384
    return -1;
385
    }
386

    
387
///////////////////////////////////////////////////////////////////////////////////////////////////
388

    
389
  public static int unpackObject(int number)
390
    {
391
    int num;
392

    
393
    for(int i=0; i<NUM_OBJECTS; i++)
394
      {
395
      num = objects[i].mObjectSizes.length;
396
      if( number<num ) return i;
397
      number -= num;
398
      }
399

    
400
    return -1;
401
    }
402

    
403
///////////////////////////////////////////////////////////////////////////////////////////////////
404

    
405
  public static int unpackObjectFromString(String obj)
406
    {
407
    int u = obj.indexOf('_');
408
    int l = obj.length();
409

    
410
    if( u>0 )
411
      {
412
      String name = obj.substring(0,u);
413
      int size = Integer.parseInt( obj.substring(u+1,l) );
414

    
415
      for(int i=0; i<NUM_OBJECTS; i++)
416
        {
417
        if( objects[i].name().equals(name) )
418
          {
419
          int sizeIndex = getSizeIndex(i,size);
420
          return pack(i,sizeIndex);
421
          }
422
        }
423
      }
424

    
425
    return -1;
426
    }
427

    
428
///////////////////////////////////////////////////////////////////////////////////////////////////
429

    
430
  public static String getObjectList()
431
    {
432
    String name;
433
    StringBuilder list = new StringBuilder();
434
    int len;
435
    int[] sizes;
436

    
437
    for(int i=0; i<NUM_OBJECTS; i++)
438
      {
439
      sizes = objects[i].mObjectSizes;
440
      len   = sizes.length;
441
      name  = objects[i].name();
442

    
443
      for(int j=0; j<len; j++)
444
        {
445
        if( i>0 || j>0 ) list.append(',');
446
        list.append(name);
447
        list.append('_');
448
        list.append(sizes[j]);
449
        }
450
      }
451

    
452
    return list.toString();
453
    }
454

    
455
///////////////////////////////////////////////////////////////////////////////////////////////////
456

    
457
  public static int getTotal()
458
    {
459
    return mNumAll;
460
    }
461

    
462
///////////////////////////////////////////////////////////////////////////////////////////////////
463

    
464
  public static int getDBLevel(int ordinal, int sizeIndex)
465
    {
466
    if( ordinal>=0 && ordinal<NUM_OBJECTS )
467
      {
468
      int num = objects[ordinal].mObjectSizes.length;
469
      return sizeIndex>=0 && sizeIndex<num ? objects[ordinal].mDBLevels[sizeIndex] : 0;
470
      }
471

    
472
    return 0;
473
    }
474

    
475
///////////////////////////////////////////////////////////////////////////////////////////////////
476

    
477
  public static int getNumScramble(int ordinal, int sizeIndex)
478
    {
479
    if( ordinal>=0 && ordinal<NUM_OBJECTS )
480
      {
481
      int num = objects[ordinal].mObjectSizes.length;
482
      return sizeIndex>=0 && sizeIndex<num ? objects[ordinal].mNumScrambles[sizeIndex] : 0;
483
      }
484

    
485
    return 0;
486
    }
487

    
488
///////////////////////////////////////////////////////////////////////////////////////////////////
489

    
490
  public static int getOrdinal(String name)
491
    {
492
    for(int i=0; i<NUM_OBJECTS; i++)
493
      {
494
      if(objects[i].name().equals(name)) return i;
495
      }
496

    
497
    return -1;
498
    }
499

    
500
///////////////////////////////////////////////////////////////////////////////////////////////////
501

    
502
  public static int getSizeIndex(int ordinal, int size)
503
    {
504
    if( ordinal>=0 && ordinal<NUM_OBJECTS )
505
      {
506
      int[] sizes = objects[ordinal].getSizes();
507
      int len = sizes.length;
508

    
509
      for(int i=0; i<len; i++)
510
        {
511
        if( sizes[i]==size ) return i;
512
        }
513
      }
514

    
515
    return -1;
516
    }
517

    
518
///////////////////////////////////////////////////////////////////////////////////////////////////
519

    
520
  public static int[] retFaceColors(ObjectList object)
521
    {
522
    Field field;
523
    int[] faceColors=null;
524

    
525
    try
526
      {
527
      field = object.mObjectClass.getDeclaredField("FACE_COLORS");
528
      field.setAccessible(true);
529
      Object obj = field.get(null);
530
      faceColors = (int[]) obj;
531
      }
532
    catch(NoSuchFieldException ex)
533
      {
534
      android.util.Log.e("RubikObjectList", object.mObjectClass.getSimpleName()+": no such field exception getting field: "+ex.getMessage());
535
      }
536
    catch(IllegalAccessException ex)
537
      {
538
      android.util.Log.e("RubikObjectList", object.mObjectClass.getSimpleName()+": illegal access exception getting field: "+ex.getMessage());
539
      }
540

    
541
    return faceColors;
542
    }
543

    
544
///////////////////////////////////////////////////////////////////////////////////////////////////
545

    
546
  ObjectList(int[][] info, Class<? extends TwistyObject> object , Movement movement, int row, int fov)
547
    {
548
    mNumSizes = info.length;
549

    
550
    mObjectSizes  = new int[mNumSizes];
551
    mDBLevels     = new int[mNumSizes];
552
    mNumScrambles = new int[mNumSizes];
553
    mResourceIDs  = new int[mNumSizes];
554
    mSmallIconIDs = new int[mNumSizes];
555
    mMediumIconIDs= new int[mNumSizes];
556
    mBigIconIDs   = new int[mNumSizes];
557
    mHugeIconIDs  = new int[mNumSizes];
558

    
559
    for(int i=0; i<mNumSizes; i++)
560
      {
561
      mObjectSizes[i]  = info[i][0];
562
      mDBLevels[i]     = info[i][1];
563
      mNumScrambles[i] = info[i][2];
564
      mResourceIDs[i]  = info[i][3];
565
      mSmallIconIDs[i] = info[i][4];
566
      mMediumIconIDs[i]= info[i][5];
567
      mBigIconIDs[i]   = info[i][6];
568
      mHugeIconIDs[i]  = info[i][7];
569
      }
570

    
571
    mObjectClass         = object;
572
    mObjectMovementClass = movement;
573
    mRow                 = row;
574
    mFOV                 = fov;
575
    }
576

    
577
///////////////////////////////////////////////////////////////////////////////////////////////////
578

    
579
  public int[] getSizes()
580
    {
581
    return mObjectSizes;
582
    }
583

    
584
///////////////////////////////////////////////////////////////////////////////////////////////////
585

    
586
  public int[] getDBLevels()
587
    {
588
    return mDBLevels;
589
    }
590

    
591
///////////////////////////////////////////////////////////////////////////////////////////////////
592

    
593
  public int[] getNumScrambles()
594
    {
595
    return mNumScrambles;
596
    }
597

    
598
///////////////////////////////////////////////////////////////////////////////////////////////////
599

    
600
  public int getFOV()
601
    {
602
    return mFOV;
603
    }
604

    
605
///////////////////////////////////////////////////////////////////////////////////////////////////
606

    
607
  public int[] getIconIDs()
608
    {
609
    int size = RubikActivity.getDrawableSize();
610

    
611
    switch(size)
612
      {
613
      case 0 : return mSmallIconIDs;
614
      case 1 : return mMediumIconIDs;
615
      case 2 : return mBigIconIDs;
616
      default: return mHugeIconIDs;
617
      }
618
    }
619

    
620
///////////////////////////////////////////////////////////////////////////////////////////////////
621

    
622
  public int[] getResourceIDs()
623
    {
624
    return mResourceIDs;
625
    }
626

    
627
///////////////////////////////////////////////////////////////////////////////////////////////////
628

    
629
  public int getNumVariants()
630
    {
631
    return mObjectSizes.length;
632
    }
633

    
634
///////////////////////////////////////////////////////////////////////////////////////////////////
635

    
636
  public TwistyObject create(int size, Static4D quat, int[][] moves, Resources res, int scrWidth)
637
    {
638
    DistortedTexture texture = new DistortedTexture();
639
    DistortedEffects effects = new DistortedEffects();
640
    MeshSquare mesh          = new MeshSquare(20,20);   // mesh of the node, not of the cubits
641

    
642
    switch(ordinal())
643
      {
644
      case  0: return new TwistyCube          (size, quat, texture, mesh, effects, moves, res, scrWidth);
645
      case  1: return new TwistyPyraminx      (size, quat, texture, mesh, effects, moves, res, scrWidth);
646
      case  2: return new TwistyUltimate      (size, quat, texture, mesh, effects, moves, res, scrWidth);
647
      case  3: return new TwistyKilominx      (size, quat, texture, mesh, effects, moves, res, scrWidth);
648
      case  4: return new TwistyMegaminx      (size, quat, texture, mesh, effects, moves, res, scrWidth);
649
      case  5: return new TwistyDino6         (size, quat, texture, mesh, effects, moves, res, scrWidth);
650
      case  6: return new TwistyDino4         (size, quat, texture, mesh, effects, moves, res, scrWidth);
651
      case  7: return new TwistyRedi          (size, quat, texture, mesh, effects, moves, res, scrWidth);
652
      case  8: return new TwistyHelicopter    (size, quat, texture, mesh, effects, moves, res, scrWidth);
653
      case  9: return new TwistySkewb         (size, quat, texture, mesh, effects, moves, res, scrWidth);
654
      case 10: return new TwistyIvy           (size, quat, texture, mesh, effects, moves, res, scrWidth);
655
      case 11: return new TwistyRex           (size, quat, texture, mesh, effects, moves, res, scrWidth);
656
      case 12: return new TwistyBandagedFused (size, quat, texture, mesh, effects, moves, res, scrWidth);
657
      case 13: return new TwistyBandaged2Bar  (size, quat, texture, mesh, effects, moves, res, scrWidth);
658
      case 14: return new TwistyBandaged3Plate(size, quat, texture, mesh, effects, moves, res, scrWidth);
659
      case 15: return new TwistyBandagedEvil  (size, quat, texture, mesh, effects, moves, res, scrWidth);
660
      case 16: return new TwistyDiamond       (size, quat, texture, mesh, effects, moves, res, scrWidth);
661
      case 17: return new TwistySquare1       (size, quat, texture, mesh, effects, moves, res, scrWidth);
662
      case 18: return new TwistySquare2       (size, quat, texture, mesh, effects, moves, res, scrWidth);
663
      }
664

    
665
    return null;
666
    }
667

    
668
///////////////////////////////////////////////////////////////////////////////////////////////////
669

    
670
  public Movement getObjectMovementClass()
671
    {
672
    return mObjectMovementClass;
673
    }
674
  }
(15-15/39)