Project

General

Profile

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

distorted-objectlib / src / main / java / org / distorted / objectlib / objects / TwistySquare1.java @ b8519939

1
///////////////////////////////////////////////////////////////////////////////////////////////////
2
// Copyright 2021 Leszek Koltunski                                                               //
3
//                                                                                               //
4
// This file is part of Magic Cube.                                                              //
5
//                                                                                               //
6
// Magic Cube is proprietary software licensed under an EULA which you should have received      //
7
// along with the code. If not, check https://distorted.org/magic/License-Magic-Cube.html        //
8
///////////////////////////////////////////////////////////////////////////////////////////////////
9

    
10
package org.distorted.objectlib.objects;
11

    
12
import java.io.InputStream;
13

    
14
import org.distorted.library.type.Static3D;
15
import org.distorted.library.type.Static4D;
16

    
17
import org.distorted.objectlib.helpers.FactoryCubit;
18
import org.distorted.objectlib.helpers.ObjectFaceShape;
19
import org.distorted.objectlib.helpers.ObjectSignature;
20
import org.distorted.objectlib.helpers.ObjectVertexEffects;
21
import org.distorted.objectlib.main.InitData;
22
import org.distorted.objectlib.main.ObjectSignatures;
23
import org.distorted.objectlib.main.ObjectType;
24
import org.distorted.objectlib.helpers.ObjectShape;
25
import org.distorted.objectlib.scrambling.ObjectScrambler;
26

    
27
///////////////////////////////////////////////////////////////////////////////////////////////////
28

    
29
public class TwistySquare1 extends TwistySquare
30
{
31
  private int[] mQuatIndex;
32
  private float[][] mCenters;
33

    
34
///////////////////////////////////////////////////////////////////////////////////////////////////
35

    
36
  public TwistySquare1(InitData data, int meshState, int iconMode, Static4D quat, Static3D move, float scale, InputStream stream)
37
    {
38
    super(data, meshState, iconMode, quat, move, scale, stream);
39
    }
40

    
41
///////////////////////////////////////////////////////////////////////////////////////////////////
42

    
43
  @Override
44
  public int getScrambleType()
45
    {
46
    return ObjectScrambler.SCRAMBLING_SQUARE1;
47
    }
48

    
49
///////////////////////////////////////////////////////////////////////////////////////////////////
50

    
51
  public int[][] getScrambleEdges()
52
    {
53
    return null;
54
    }
55

    
56
///////////////////////////////////////////////////////////////////////////////////////////////////
57

    
58
  public float[][] getCubitPositions(int[] numLayers)
59
    {
60
    if( mCenters==null )
61
      {
62
      mCenters = new float[][]
63
        {
64
         { 1.5f, 0.0f, 0.0f },
65
         {-1.5f, 0.0f, 0.0f },
66

    
67
         { 0.0f, 1.0f, 1.5f },
68
         { 1.5f, 1.0f, 0.0f },
69
         { 0.0f, 1.0f,-1.5f },
70
         {-1.5f, 1.0f, 0.0f },
71
         { 0.0f,-1.0f, 1.5f },
72
         { 1.5f,-1.0f, 0.0f },
73
         { 0.0f,-1.0f,-1.5f },
74
         {-1.5f,-1.0f, 0.0f },
75

    
76
         { 1.0f, 1.0f, 2.0f, 2.0f, 1.0f, 1.0f },
77
         { 1.0f, 1.0f,-2.0f, 2.0f, 1.0f,-1.0f },
78
         {-1.0f, 1.0f,-2.0f,-2.0f, 1.0f,-1.0f },
79
         {-1.0f, 1.0f, 2.0f,-2.0f, 1.0f, 1.0f },
80
         { 1.0f,-1.0f, 2.0f, 2.0f,-1.0f, 1.0f },
81
         { 1.0f,-1.0f,-2.0f, 2.0f,-1.0f,-1.0f },
82
         {-1.0f,-1.0f,-2.0f,-2.0f,-1.0f,-1.0f },
83
         {-1.0f,-1.0f, 2.0f,-2.0f,-1.0f, 1.0f }
84
        };
85
      }
86
    return mCenters;
87
    }
88

    
89
///////////////////////////////////////////////////////////////////////////////////////////////////
90

    
91
  public Static4D getCubitQuats(int cubit, int[] numLayers)
92
    {
93
    if( mQuatIndex ==null )
94
      {
95
      mQuatIndex = new int[]
96
        {
97
        0, 6,
98
        0, 9, 6, 3, 17, 14, 23, 20,
99
        0, 9, 6, 3, 14, 23, 20, 17
100
        };
101
      }
102

    
103
    return mObjectQuats[mQuatIndex[cubit]];
104
    }
105

    
106
///////////////////////////////////////////////////////////////////////////////////////////////////
107

    
108
  private float[][] getVertices(int variant)
109
    {
110
    if( variant==0 )
111
      {
112
      return new float[][]
113
        {
114
         { -1.5f-X, 0.5f, 1.5f },
115
         {    0.0f, 0.5f, 1.5f },
116
         {    0.0f, 0.5f,-1.5f },
117
         { -1.5f+X, 0.5f,-1.5f },
118
         { -1.5f-X,-0.5f, 1.5f },
119
         {    0.0f,-0.5f, 1.5f },
120
         {    0.0f,-0.5f,-1.5f },
121
         { -1.5f+X,-0.5f,-1.5f }
122
        };
123
      }
124
    else if( variant==1 )
125
      {
126
      return new float[][]
127
        {
128
         {  -X, 0.5f, 0.0f },
129
         {  +X, 0.5f, 0.0f },
130
         {0.0f, 0.5f,-1.5f },
131
         {  -X,-0.5f, 0.0f },
132
         {  +X,-0.5f, 0.0f },
133
         {0.0f,-0.5f,-1.5f },
134
        };
135
      }
136
    else
137
      {
138
      return new float[][]
139
        {
140
         { X-1.5f, 0.5f,  0.0f },
141
         {   0.0f, 0.5f,  0.0f },
142
         {   0.0f, 0.5f,X-1.5f },
143
         {  -1.5f, 0.5f, -1.5f },
144
         { X-1.5f,-0.5f,  0.0f },
145
         {   0.0f,-0.5f,  0.0f },
146
         {   0.0f,-0.5f,X-1.5f },
147
         {  -1.5f,-0.5f, -1.5f }
148
        };
149
      }
150
    }
151

    
152
///////////////////////////////////////////////////////////////////////////////////////////////////
153

    
154
  public ObjectShape getObjectShape(int variant)
155
    {
156
    if( variant==0 )
157
      {
158
      int[][] indices =
159
        {
160
         {4,5,1,0},
161
         {5,6,2,1},
162
         {6,7,3,2},
163
         {7,4,0,3},
164
         {0,1,2,3},
165
         {7,6,5,4}
166
        };
167

    
168
      return new ObjectShape(getVertices(variant), indices);
169
      }
170
    else if( variant==1 )
171
      {
172
      int[][] indices =
173
        {
174
         {0,1,2},
175
         {3,4,1,0},
176
         {5,4,3},
177
         {4,5,2,1},
178
         {5,3,0,2}
179
        };
180

    
181
      return new ObjectShape(getVertices(variant), indices);
182
      }
183
    else
184
      {
185
      int[][] indices =
186
        {
187
         {0,1,2,3},
188
         {4,5,1,0},
189
         {5,6,2,1},
190
         {7,4,0,3},
191
         {6,7,3,2},
192
         {7,6,5,4}
193
        };
194

    
195
      return new ObjectShape(getVertices(variant), indices);
196
      }
197
    }
198

    
199
///////////////////////////////////////////////////////////////////////////////////////////////////
200

    
201
  public ObjectFaceShape getObjectFaceShape(int variant)
202
    {
203
    if( variant==0 )
204
      {
205
      float h1 = isInIconMode() ? 0.001f : 0.04f;
206
      float h2 = isInIconMode() ? 0.001f : 0.02f;
207
      float[][] bands = { {h1,35,0.2f,0.8f,5,2,1}, {h2,35,0.5f,1.0f,5,2,1}, {0.001f,35,0.3f,0.8f,5,2,1} };
208
      int[] indices   = { 0,0,1,2,2,2 };
209
      return new ObjectFaceShape(bands,indices,null);
210
      }
211
    else if( variant==1 )
212
      {
213
      float height = isInIconMode() ? 0.001f : 0.038f;
214
      float[][] bands = { {height,35,0.5f,0.9f, 5,2,1}, {0.001f,35,0.5f,0.9f, 5,2,1} };
215
      int[] indices   = { 0,0,0,1,1 };
216
      return new ObjectFaceShape(bands,indices,null);
217
      }
218
    else
219
      {
220
      float height = isInIconMode() ? 0.001f : 0.038f;
221
      float[][] bands = { {height,35,0.9f,1.0f, 5,2,1}, {0.001f,35,0.9f,1.0f, 5,2,1} };
222
      int[] indices   = { 0,0,0,1,1,1 };
223
      return new ObjectFaceShape(bands,indices,null);
224
      }
225
    }
226

    
227
///////////////////////////////////////////////////////////////////////////////////////////////////
228

    
229
  public ObjectVertexEffects getVertexEffects(int variant)
230
    {
231
    if( variant==0 )
232
      {
233
      float[][] corners = { {0.03f,0.05f} };
234
      int[] indices     = { 0,0,0,0,0,0,0,0 };
235
      float[][] centers = { { -0.75f, 0.0f, 0.0f} };
236
      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);
237
      }
238
    else if( variant==1 )
239
      {
240
      float[][] corners = { {0.04f,0.15f} };
241
      int[] indices     = { 0,0,-1,0,0,-1 };
242
      float[][] centers = { { 0.0f, 0.0f,-0.5f} };
243
      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,indices,centers,indices);
244
      }
245
    else
246
      {
247
      float[][] corners   = { {0.05f,0.13f} };
248
      int[] cornerIndices = { 0,0,0,-1,0,0,0,-1 };
249
      float[][] centers   = { { -0.5f, 0.0f,-0.5f} };
250
      int[] centerIndices = { -1,0,-1,-1,-1,0,-1,-1 };
251
      return FactoryCubit.generateVertexEffect(getVertices(variant),corners,cornerIndices,centers,centerIndices);
252
      }
253
    }
254

    
255
///////////////////////////////////////////////////////////////////////////////////////////////////
256

    
257
  public int getNumCubitVariants(int[] numLayers)
258
    {
259
    return 3;
260
    }
261

    
262
///////////////////////////////////////////////////////////////////////////////////////////////////
263

    
264
  public int getCubitVariant(int cubit, int[] numLayers)
265
    {
266
    return cubit<2 ? 0 : (cubit<10 ? 1:2);
267
    }
268

    
269
///////////////////////////////////////////////////////////////////////////////////////////////////
270

    
271
  public float getStickerRadius()
272
    {
273
    return 0.12f;
274
    }
275

    
276
///////////////////////////////////////////////////////////////////////////////////////////////////
277

    
278
  public float getStickerStroke()
279
    {
280
    return isInIconMode() ? 0.20f : 0.10f;
281
    }
282

    
283
///////////////////////////////////////////////////////////////////////////////////////////////////
284

    
285
  public float[][] getStickerAngles()
286
    {
287
    return null;
288
    }
289

    
290
///////////////////////////////////////////////////////////////////////////////////////////////////
291
// PUBLIC API
292

    
293
  public String getShortName()
294
    {
295
    return ObjectType.SQU1_3.name();
296
    }
297

    
298
///////////////////////////////////////////////////////////////////////////////////////////////////
299

    
300
  public ObjectSignature getSignature()
301
    {
302
    return new ObjectSignature(ObjectSignatures.SQU1_3);
303
    }
304

    
305
///////////////////////////////////////////////////////////////////////////////////////////////////
306

    
307
  public String getObjectName()
308
    {
309
    return "Square-1";
310
    }
311

    
312
///////////////////////////////////////////////////////////////////////////////////////////////////
313

    
314
  public String getInventor()
315
    {
316
    return "V. Kopsky, K. Hrsel";
317
    }
318

    
319
///////////////////////////////////////////////////////////////////////////////////////////////////
320

    
321
  public int getYearOfInvention()
322
    {
323
    return 1990;
324
    }
325

    
326
///////////////////////////////////////////////////////////////////////////////////////////////////
327

    
328
  public int getComplexity()
329
    {
330
    return 3;
331
    }
332

    
333
///////////////////////////////////////////////////////////////////////////////////////////////////
334

    
335
  public String[][] getTutorials()
336
    {
337
    return new String[][]{
338
                          {"gb","0tX-f6RLgac","How to Solve the Square-1","Z3"},
339
                          {"es","mGtHDWj_i1o","Resolver SQUARE-1","Cuby"},
340
                          {"ru","XguuJTUwJoE","Как собрать Скваер-1","Алексей Ярыгин"},
341
                          {"fr","knRmTSa6aHQ","Comment résoudre le Square-1 (1/3)","Valentino Cube"},
342
                          {"fr","y-0ZrAgzETI","Comment résoudre le Square-1 (2/3)","Valentino Cube"},
343
                          {"fr","tYbE9GfEokw","Comment résoudre le Square-1 (3/3)","Valentino Cube"},
344
                          {"de","p9DMIzNQ3b8","Square-1 Tutorial (1/2)","Pezcraft"},
345
                          {"de","gM6E28JGmoo","Square-1 Tutorial (2/2)","Pezcraft"},
346
                          {"pl","_0rsImrp9jc","Jak ułożyć: Square-1","DżoDżo"},
347
                          {"br","geT7SvX0DEw","Tutorial do Square-1","Pedro Filho"},
348
                          {"kr","NcB50lWdQzE","스퀘어1 맞추는 방법","iamzoone"},
349
                          {"vn","YvCZXkbZnNs","Tutorial N.120 - Square 1","Duy Thích Rubik"},
350
                         };
351
    }
352
}
(35-35/41)