Project

General

Profile

« Previous | Next » 

Revision e42a9e87

Added by Leszek Koltunski over 3 years ago

Fix the Square-2 isSolved() (it was wrong even before!)

View differences:

src/main/java/org/distorted/objects/TwistyObject.java
454 454
    if( mSolvedFunctionIndex==0 ) return isSolved0();
455 455
    if( mSolvedFunctionIndex==1 ) return isSolved1();
456 456
    if( mSolvedFunctionIndex==2 ) return isSolved2();
457
    if( mSolvedFunctionIndex==3 ) return isSolved3();
457 458

  
458 459
    return false;
459 460
    }
......
588 589
      }
589 590

  
590 591
    return ( qX==qY && qX==qZ ) || ( qY==mulQuat(qX,2) && qZ==mulQuat(qX,8) );
592
    }
593

  
594
///////////////////////////////////////////////////////////////////////////////////////////////////
595
// Square-2 is solved iff
596
// a) all of its cubits are rotated with the same quat
597
// b) its two 'middle' cubits are rotated with the same quat, the 6 'front' and 6 'back'
598
// edges and corners with this quat multiplied by QUATS[18] (i.e. those are upside down)
599
// and all the 12 left and right edges and corners also with the same quat multiplied by
600
// QUATS[12] - i.e. also upside down.
601

  
602
  public boolean isSolved3()
603
    {
604
    int index = CUBITS[0].mQuatIndex;
605

  
606
    if( CUBITS[1].mQuatIndex!=index ) return false;
607

  
608
    boolean solved = true;
609

  
610
    for(int i=2; i<NUM_CUBITS; i++)
611
      {
612
      if( CUBITS[i].mQuatIndex!=index )
613
        {
614
        solved = false;
615
        break;
616
        }
617
      }
591 618

  
619
    if( solved ) return true;
620

  
621
    int indexX = mulQuat(index,12);  // QUATS[12] = 180deg (1,0,0)
622
    int indexZ = mulQuat(index,18);  // QUATS[18] = 180deg (0,0,1)
623

  
624
    for(int i= 2; i<        18; i+=2) if( CUBITS[i].mQuatIndex != indexZ ) return false;
625
    for(int i= 3; i<        18; i+=2) if( CUBITS[i].mQuatIndex != indexX ) return false;
626
    for(int i=18; i<NUM_CUBITS; i+=2) if( CUBITS[i].mQuatIndex != indexX ) return false;
627
    for(int i=19; i<NUM_CUBITS; i+=2) if( CUBITS[i].mQuatIndex != indexZ ) return false;
628

  
629
    return true;
592 630
    }
593 631

  
594 632
///////////////////////////////////////////////////////////////////////////////////////////////////
src/main/java/org/distorted/objects/TwistySquare.java
220 220
    return FACE_COLORS[face];
221 221
    }
222 222

  
223
///////////////////////////////////////////////////////////////////////////////////////////////////
224

  
225
  int getSolvedFunctionIndex()
226
    {
227
    return 0;
228
    }
229

  
230 223
///////////////////////////////////////////////////////////////////////////////////////////////////
231 224
// PUBLIC API
232 225

  
src/main/java/org/distorted/objects/TwistySquare1.java
260 260
    return CENTERS;
261 261
    }
262 262

  
263
///////////////////////////////////////////////////////////////////////////////////////////////////
264

  
265
  int getSolvedFunctionIndex()
266
    {
267
    return 0;
268
    }
269

  
263 270
///////////////////////////////////////////////////////////////////////////////////////////////////
264 271

  
265 272
  int getNumStickerTypes(int numLayers)
src/main/java/org/distorted/objects/TwistySquare2.java
182 182
    }
183 183

  
184 184
///////////////////////////////////////////////////////////////////////////////////////////////////
185
// Square-2 is solved iff
186
// a) all of its cubits are rotated with the same quat
187
// b) its two 'middle' cubits are rotated with the same quat, the 6 'front' and 6 'back'
188
// edges and corners with this quat multiplied by QUATS[18] (i.e. those are upside down)
189
// and all the 12 left and right edges and corners also with the same quat multiplied by
190
// QUATS[12] - i.e. also upside down.
191

  
192
  private static final int[] S18 = new int[] {18};
193
  private static final int[] S12 = new int[] {12};
194 185

  
195 186
  int[] getSolvedQuats(int cubit, int numLayers)
196 187
    {
197
    switch(cubit)
198
      {
199
      case  0: case  1: return null;
200
      case  2: case  4: case  6: case  8:
201
      case 10: case 12: case 14: case 16:
202
      case 19: case 21: case 23: case 25: return S18;
203
      case  3: case  5: case  7: case  9:
204
      case 11: case 13: case 15: case 17:
205
      case 18: case 20: case 22: case 24: return S12;
206
      }
207

  
208 188
    return null;
209 189
    }
210 190

  
......
281 261
    return CENTERS;
282 262
    }
283 263

  
264
///////////////////////////////////////////////////////////////////////////////////////////////////
265

  
266
  int getSolvedFunctionIndex()
267
    {
268
    return 3;
269
    }
270

  
284 271
///////////////////////////////////////////////////////////////////////////////////////////////////
285 272

  
286 273
  int getNumStickerTypes(int numLayers)

Also available in: Unified diff