Project

General

Profile

Download (15.8 KB) Statistics
| Branch: | Revision:

distorted-objectlib / src / main / java / org / distorted / objectlib / objects / TwistyIvy.java @ cde08c52

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.objectlib.objects;
21

    
22
import static org.distorted.objectlib.touchcontrol.TouchControl.TYPE_SPLIT_CORNER;
23
import static org.distorted.objectlib.touchcontrol.TouchControl.TC_HEXAHEDRON;
24

    
25
import java.io.InputStream;
26

    
27
import org.distorted.library.type.Static3D;
28
import org.distorted.library.type.Static4D;
29

    
30
import org.distorted.objectlib.helpers.ObjectFaceShape;
31
import org.distorted.objectlib.touchcontrol.TouchControlHexahedron;
32
import org.distorted.objectlib.main.ObjectType;
33
import org.distorted.objectlib.helpers.ObjectShape;
34
import org.distorted.objectlib.scrambling.ScrambleState;
35
import org.distorted.objectlib.main.ShapeHexahedron;
36

    
37
///////////////////////////////////////////////////////////////////////////////////////////////////
38

    
39
public class TwistyIvy extends ShapeHexahedron
40
{
41
  static final Static3D[] ROT_AXIS = new Static3D[]
42
         {
43
           new Static3D(+SQ3/3,+SQ3/3,+SQ3/3),
44
           new Static3D(+SQ3/3,+SQ3/3,-SQ3/3),
45
           new Static3D(+SQ3/3,-SQ3/3,+SQ3/3),
46
           new Static3D(+SQ3/3,-SQ3/3,-SQ3/3)
47
         };
48

    
49
  public static final float IVY_D = 0.006f;
50
  private static final int  IVY_N = 8;
51

    
52
  private ScrambleState[] mStates;
53
  private int[][] mBasicAngle;
54
  private float[][] mCuts;
55
  private int[] mQuatIndex;
56

    
57
///////////////////////////////////////////////////////////////////////////////////////////////////
58

    
59
  public TwistyIvy(int[] numL, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)
60
    {
61
    super(numL, meshState, iconMode, numL[0], quat, move, scale, stream);
62
    }
63

    
64
///////////////////////////////////////////////////////////////////////////////////////////////////
65
// ditto, manually provide the sticker coordinates.
66

    
67
  @Override
68
  public void adjustStickerCoords()
69
    {
70
    float B = 1.08f;
71
    float A1 = B*0.41f;
72
    float A2 = B*0.46f;
73

    
74
    mStickerCoords = new float[][]
75
          {
76
            { 0.29258922f, -0.5f, 0.29258922f, 0.29258922f, -0.5f, 0.29258922f },
77
            { -A1,A1,A2,-A2 }
78
          };
79
    }
80

    
81
///////////////////////////////////////////////////////////////////////////////////////////////////
82

    
83
  public ScrambleState[] getScrambleStates()
84
    {
85
    if( mStates==null )
86
      {
87
      int[] tmp = {0,-1,0, 0,1,0, 1,-1,0, 1,1,0 };
88

    
89
      mStates = new ScrambleState[]
90
        {
91
        new ScrambleState( new int[][] {tmp,tmp,tmp,tmp} )
92
        };
93
      }
94

    
95
    return mStates;
96
    }
97

    
98
///////////////////////////////////////////////////////////////////////////////////////////////////
99

    
100
  public float[][] getCuts(int[] numLayers)
101
    {
102
    if( mCuts==null )
103
      {
104
      float[] cut = new float[] {0.0f};
105
      mCuts = new float[][] { cut,cut,cut,cut };
106
      }
107

    
108
    return mCuts;
109
    }
110

    
111
///////////////////////////////////////////////////////////////////////////////////////////////////
112

    
113
  public boolean[][] getLayerRotatable(int[] numLayers)
114
    {
115
    int numAxis = ROT_AXIS.length;
116
    boolean[][] layerRotatable = new boolean[numAxis][];
117

    
118
    for(int i=0; i<numAxis; i++)
119
      {
120
      layerRotatable[i] = new boolean[numLayers[i]];
121
      for(int j=0; j<numLayers[i]; j++) layerRotatable[i][j] = true;
122
      }
123

    
124
    return layerRotatable;
125
    }
126

    
127
///////////////////////////////////////////////////////////////////////////////////////////////////
128

    
129
  public int getTouchControlType()
130
    {
131
    return TC_HEXAHEDRON;
132
    }
133

    
134
///////////////////////////////////////////////////////////////////////////////////////////////////
135

    
136
  public int getTouchControlSplit()
137
    {
138
    return TYPE_SPLIT_CORNER;
139
    }
140

    
141
///////////////////////////////////////////////////////////////////////////////////////////////////
142

    
143
  public int[][][] getEnabled()
144
    {
145
    return new int[][][]
146
      {
147
          {{0},{3},{3},{0}},
148
          {{2},{1},{1},{2}},
149
          {{2},{0},{0},{2}},
150
          {{1},{3},{3},{1}},
151
          {{0},{0},{1},{1}},
152
          {{2},{2},{3},{3}},
153
      };
154
    }
155

    
156
///////////////////////////////////////////////////////////////////////////////////////////////////
157

    
158
  public float[] getDist3D(int[] numLayers)
159
    {
160
    return TouchControlHexahedron.D3D;
161
    }
162

    
163
///////////////////////////////////////////////////////////////////////////////////////////////////
164

    
165
  public Static3D[] getFaceAxis()
166
    {
167
    return TouchControlHexahedron.FACE_AXIS;
168
    }
169

    
170
///////////////////////////////////////////////////////////////////////////////////////////////////
171

    
172
  public float[][] getCubitPositions(int[] numLayers)
173
    {
174
    final float DIST_CORNER = numLayers[0]-1;
175
    final float DIST_CENTER = numLayers[0]-1;
176

    
177
    return new float[][]
178
      {
179
        { DIST_CORNER, DIST_CORNER, DIST_CORNER },
180
        {-DIST_CORNER, DIST_CORNER,-DIST_CORNER },
181
        {-DIST_CORNER,-DIST_CORNER, DIST_CORNER },
182
        { DIST_CORNER,-DIST_CORNER,-DIST_CORNER },
183
        {           0,           0, DIST_CENTER },
184
        {           0,           0,-DIST_CENTER },
185
        {           0, DIST_CENTER,           0 },
186
        {           0,-DIST_CENTER,           0 },
187
        { DIST_CENTER,           0,           0 },
188
        {-DIST_CENTER,           0,           0 },
189
      };
190
    }
191

    
192
///////////////////////////////////////////////////////////////////////////////////////////////////
193

    
194
  public Static4D getCubitQuats(int cubit, int[] numLayers)
195
    {
196
    if( mQuatIndex==null ) mQuatIndex = new int[] { 0,11,10, 9,
197
                                                    0,11, 7, 6, 5, 8
198
                                                  };
199
    return mObjectQuats[mQuatIndex[cubit]];
200
    }
201

    
202
///////////////////////////////////////////////////////////////////////////////////////////////////
203

    
204
  public ObjectShape getObjectShape(int variant)
205
    {
206
    if( variant==0 )
207
      {
208
      final float A = 0.3f;
209
      final float angle = (float)Math.PI/(2*IVY_N);
210
      final float CORR  = 1-2*IVY_D;
211
      float[][] vertices= new float[3*(IVY_N+1)+5][3];
212
      int[][] indices   = new int[3*IVY_N+3][];
213

    
214
      indices[0] = new int[IVY_N+4];
215
      indices[1] = new int[IVY_N+4];
216
      indices[2] = new int[IVY_N+4];
217

    
218
      vertices[3*(IVY_N+1)+4][0] = -A;
219
      vertices[3*(IVY_N+1)+4][1] = -A;
220
      vertices[3*(IVY_N+1)+4][2] = -A;
221

    
222
      vertices[0][0] = 0;
223
      vertices[0][1] = 0;
224
      vertices[0][2] = 0;
225
      vertices[1][0] =-2;
226
      vertices[1][1] = 0;
227
      vertices[1][2] = 0;
228
      vertices[2][0] = 0;
229
      vertices[2][1] =-2;
230
      vertices[2][2] = 0;
231
      vertices[3][0] = 0;
232
      vertices[3][1] = 0;
233
      vertices[3][2] =-2;
234

    
235
      indices[0][0] = 2;
236
      indices[0][1] = 0;
237
      indices[0][2] = 1;
238
      indices[1][0] = 3;
239
      indices[1][1] = 0;
240
      indices[1][2] = 2;
241
      indices[2][0] = 1;
242
      indices[2][1] = 0;
243
      indices[2][2] = 3;
244

    
245
      int N1 = 4;
246
      int N2 = N1 + IVY_N + 1;
247
      int N3 = N2 + IVY_N + 1;
248

    
249
      for(int i=0; i<=IVY_N; i++)
250
        {
251
        float cos1 = (float)Math.cos((IVY_N-i)*angle);
252
        float sin1 = (float)Math.sin((IVY_N-i)*angle);
253
        float cos2 = (float)Math.cos((      i)*angle);
254
        float sin2 = (float)Math.sin((      i)*angle);
255

    
256
        vertices[N1+i][0] = CORR*(2*cos1-1) - 1;
257
        vertices[N1+i][1] = CORR*(2*sin1-1) - 1;
258
        vertices[N1+i][2] = 0;
259

    
260
        vertices[N2+i][0] = 0;
261
        vertices[N2+i][1] = CORR*(2*sin2-1) - 1;
262
        vertices[N2+i][2] = CORR*(2*cos2-1) - 1;
263

    
264
        vertices[N3+i][0] = CORR*(2*cos2-1) - 1;
265
        vertices[N3+i][1] = 0;
266
        vertices[N3+i][2] = CORR*(2*sin2-1) - 1;
267

    
268
        indices[0][i+3] = N1 + i;
269
        indices[1][i+3] = N2 + i;
270
        indices[2][i+3] = N3 + i;
271
        }
272

    
273
      for(int i=0; i<IVY_N; i++)
274
        {
275
        indices[3*i+3] = new int[] { N1+i+1, N1+i, 3*(IVY_N+1)+4 };
276
        indices[3*i+4] = new int[] { N2+i+1, N2+i, 3*(IVY_N+1)+4 };
277
        indices[3*i+5] = new int[] { N3+i+1, N3+i, 3*(IVY_N+1)+4 };
278
        }
279

    
280
      return new ObjectShape(vertices, indices);
281
      }
282
    else
283
      {
284
      final float angle = (float)Math.PI/(2*IVY_N);
285
      final float CORR  = 1-2*IVY_D;
286
      float[][] vertices= new float[2*IVY_N+1][3];
287
      int[][] indices   = new int[2*IVY_N+1][];
288

    
289
      for(int i=0; i<IVY_N; i++)
290
        {
291
        float sin = (float)Math.sin(i*angle);
292
        float cos = (float)Math.cos(i*angle);
293

    
294
        vertices[i      ][0] = CORR*(1-2*cos);
295
        vertices[i      ][1] = CORR*(1-2*sin);
296
        vertices[i      ][2] = 0;
297
        vertices[i+IVY_N][0] = CORR*(2*cos-1);
298
        vertices[i+IVY_N][1] = CORR*(2*sin-1);
299
        vertices[i+IVY_N][2] = 0;
300
        }
301

    
302
      vertices[2*IVY_N][0] = 0.0f;
303
      vertices[2*IVY_N][1] = 0.0f;
304
      vertices[2*IVY_N][2] =-0.1f;
305

    
306
      indices[0] = new int[2*IVY_N+1];
307
      for(int i=0; i<2*IVY_N; i++)
308
        {
309
        indices[0][i] = i;
310
        indices[i+1]  = new int[] {i+1,i,2*IVY_N};
311
        }
312
      indices[2*IVY_N][0] = 0;
313

    
314
      return new ObjectShape(vertices, indices);
315
      }
316
    }
317

    
318
///////////////////////////////////////////////////////////////////////////////////////////////////
319

    
320
  public ObjectFaceShape getObjectFaceShape(int variant)
321
    {
322
    if( variant==0 )
323
      {
324
      float height = isInIconMode() ? 0.001f : 0.015f;
325
      float[][] centers  = { {-1.0f,-1.0f,-1.0f} };
326
      float[][] corners  = { {0.04f,0.20f}, {0.03f,0.20f} };
327
      float[][] bands    = { {height,20,0.2f,0.5f,7,1,2}, {0.001f,1,0.2f,0.0f,2,0,0} };
328

    
329
      int[] cornerIndices= new int[3*(IVY_N+1)+5];
330
      int[] centerIndices= new int[3*(IVY_N+1)+5];
331
      int[] bandIndices  = new int[3*(IVY_N+1)  ];
332

    
333
      for(int i=0; i<3*(IVY_N+1); i++)
334
        {
335
        cornerIndices[i+4] = -1;
336
        centerIndices[i+4] = -1;
337
        bandIndices[i] = 1;
338
        }
339

    
340
      cornerIndices[3*(IVY_N+1)+4] = -1;
341
      centerIndices[3*(IVY_N+1)+4] = -1;
342

    
343
      bandIndices[0] = 0;
344
      bandIndices[1] = 0;
345
      bandIndices[2] = 0;
346

    
347
      cornerIndices[0] = 1;
348
      cornerIndices[1] = 0;
349
      cornerIndices[2] = 0;
350
      cornerIndices[3] = 0;
351

    
352
      centerIndices[0] = 0;
353
      centerIndices[1] = 0;
354
      centerIndices[2] = 0;
355
      centerIndices[3] = 0;
356

    
357
      float C = 1-SQ2/2;
358
      float[] convexCenter = {-C,-C,-C};
359
      return new ObjectFaceShape(bands,bandIndices,corners,cornerIndices,centers,centerIndices,convexCenter);
360
      }
361
    else
362
      {
363
      float h1 = isInIconMode() ? 0.001f : 0.03f;
364
      float h2 = isInIconMode() ? 0.001f : 0.01f;
365
      float[][] corners= { {0.04f,0.20f} };
366
      float[][] centers= { {-0.0f,-0.0f,-1.0f} };
367
      float[][] bands  = { { h1,35,0.5f,0.5f,5,0,0}, {h2,1,0.5f,0.8f,2,0,0} };
368

    
369
      int[] bandIndices= new int[2*IVY_N+1];
370
      int[] indexes = new int[2*IVY_N+1];
371
      for(int i=0; i<2*IVY_N+1; i++)
372
        {
373
        indexes[i] = -1;
374
        bandIndices[i] = 1;
375
        }
376
      indexes[0] = indexes[IVY_N] = 0;
377
      bandIndices[0] = 0;
378

    
379
      return new ObjectFaceShape(bands,bandIndices,corners,indexes,centers,indexes, null);
380
      }
381
    }
382

    
383
///////////////////////////////////////////////////////////////////////////////////////////////////
384

    
385
  public int getNumCubitVariants(int[] numLayers)
386
    {
387
    return 2;
388
    }
389

    
390
///////////////////////////////////////////////////////////////////////////////////////////////////
391

    
392
  public int getCubitVariant(int cubit, int[] numLayers)
393
    {
394
    return cubit<4 ? 0:1;
395
    }
396

    
397
///////////////////////////////////////////////////////////////////////////////////////////////////
398

    
399
  public float getStickerRadius()
400
    {
401
    return 0.19f;
402
    }
403

    
404
///////////////////////////////////////////////////////////////////////////////////////////////////
405

    
406
  public float getStickerStroke()
407
    {
408
    return isInIconMode() ? 0.16f : 0.12f;
409
    }
410

    
411
///////////////////////////////////////////////////////////////////////////////////////////////////
412

    
413
  public float[][] getStickerAngles()
414
    {
415
    float D = (float)(Math.PI/4);
416
    return new float[][] { { 0,0,-D },{ D,D } };
417
    }
418

    
419
///////////////////////////////////////////////////////////////////////////////////////////////////
420
// PUBLIC API
421

    
422
  public Static3D[] getRotationAxis()
423
    {
424
    return ROT_AXIS;
425
    }
426

    
427
///////////////////////////////////////////////////////////////////////////////////////////////////
428

    
429
  public int[][] getBasicAngles()
430
    {
431
    if( mBasicAngle ==null )
432
      {
433
      int num = getNumLayers()[0];
434
      int[] tmp = new int[num];
435
      for(int i=0; i<num; i++) tmp[i] = 3;
436
      mBasicAngle = new int[][] { tmp,tmp,tmp,tmp };
437
      }
438

    
439
    return mBasicAngle;
440
    }
441

    
442
///////////////////////////////////////////////////////////////////////////////////////////////////
443

    
444
  public String getShortName()
445
    {
446
    return ObjectType.IVY_2.name();
447
    }
448

    
449
///////////////////////////////////////////////////////////////////////////////////////////////////
450

    
451
  public long getSignature()
452
    {
453
    return ObjectType.IVY_2.ordinal();
454
    }
455

    
456
///////////////////////////////////////////////////////////////////////////////////////////////////
457

    
458
  public String getObjectName()
459
    {
460
    return "Ivy Cube";
461
    }
462

    
463
///////////////////////////////////////////////////////////////////////////////////////////////////
464

    
465
  public String getInventor()
466
    {
467
    return "Eitan Cher";
468
    }
469

    
470
///////////////////////////////////////////////////////////////////////////////////////////////////
471

    
472
  public int getYearOfInvention()
473
    {
474
    return 2009;
475
    }
476

    
477
///////////////////////////////////////////////////////////////////////////////////////////////////
478

    
479
  public int getComplexity()
480
    {
481
    return 0;
482
    }
483

    
484
///////////////////////////////////////////////////////////////////////////////////////////////////
485

    
486
  public String[][] getTutorials()
487
    {
488
    return new String[][]{
489
                          {"gb","QMzeJobSu1M","How to Solve the Ivy Cube","Z3"},
490
                          {"es","2-Gf2cmEJDs","Resolver Ivy Cube","Cuby"},
491
                          {"ru","pbkfOCnnfsA","Как собрать Иви куб","Алексей Ярыгин"},
492
                          {"fr","mn7YTnYu3Uc","Comment résoudre le Ivy Cube","ValentinoCube"},
493
                          {"de","vaW5fSUG_O8","Ivy Cube","ThomasStadler"},
494
                          {"pl","8s_0VxNvFA8","Jak ułożyć Ivy Cube","DubiCube"},
495
                          {"kr","TmSPgjtSFac","15분만에 아이비큐브 완전정복하기!","초등취미생활"},
496
                          {"vn","Ktx9KQr_8qo","Tutorial N.29 - Ivy Cube","Duy Thích Rubik"},
497
                         };
498
    }
499
}
(17-17/36)