Revision 882a8142
Added by Leszek Koltunski almost 2 years ago
| src/main/java/org/distorted/objectlib/helpers/ObjectSignature.java | ||
|---|---|---|
| 9 | 9 |
|
| 10 | 10 |
package org.distorted.objectlib.helpers; |
| 11 | 11 |
|
| 12 |
import java.util.ArrayList; |
|
| 13 |
|
|
| 12 | 14 |
import org.distorted.objectlib.main.ObjectType; |
| 13 | 15 |
|
| 14 |
import java.util.ArrayList;
|
|
| 16 |
import static org.distorted.objectlib.scrambling.ScrambleStateBandagedCuboid.MAX_SUPPORTED_SIZE;
|
|
| 15 | 17 |
|
| 16 | 18 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 17 | 19 |
|
| 18 | 20 |
public class ObjectSignature implements Comparable<ObjectSignature> |
| 19 | 21 |
{
|
| 20 |
private long mSignature1, mSignature2, mSignature3; |
|
| 22 |
public static final int SIZE = computeNum(); |
|
| 23 |
|
|
| 24 |
private long[] mSignature; |
|
| 21 | 25 |
private int[] mLayer; |
| 22 | 26 |
private int[][][][] mCycles; |
| 23 | 27 |
private float[][] mCubitTouch; |
| ... | ... | |
| 25 | 29 |
private int[] mNumLeftCyclesPerLayer; |
| 26 | 30 |
private int[] mNumCentCyclesPerLayer; |
| 27 | 31 |
private int[] mNumInneCyclesPerLayer; |
| 32 |
private String mName=null; |
|
| 33 |
|
|
| 34 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 35 |
// a cube of size N has 12*(N-1)^2 possible places two adjacent cubies can be 'glued'; therefore |
|
| 36 |
// the signature must contain ceil( 12*(N-1)^2 / 64 ) bytes. |
|
| 37 |
|
|
| 38 |
private static int computeNum() |
|
| 39 |
{
|
|
| 40 |
int max = MAX_SUPPORTED_SIZE-1; |
|
| 41 |
return (int)(0.95f + (3*max*max)/16.0f); |
|
| 42 |
} |
|
| 43 |
|
|
| 44 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 45 |
|
|
| 46 |
private void setUpSignature(long[] signature) |
|
| 47 |
{
|
|
| 48 |
int size = signature.length; |
|
| 49 |
int diff = SIZE-size; |
|
| 50 |
|
|
| 51 |
if( diff==0 ) mSignature = signature; |
|
| 52 |
else |
|
| 53 |
{
|
|
| 54 |
mSignature = new long[SIZE]; |
|
| 55 |
|
|
| 56 |
for(int i=0; i<size; i++) |
|
| 57 |
{
|
|
| 58 |
mSignature[diff+i] = signature[i]; |
|
| 59 |
} |
|
| 60 |
} |
|
| 61 |
} |
|
| 28 | 62 |
|
| 29 | 63 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 30 | 64 |
// built-in objects |
| 31 | 65 |
|
| 32 | 66 |
public ObjectSignature(ObjectType type) |
| 33 | 67 |
{
|
| 34 |
mSignature1 = 0; |
|
| 35 |
mSignature2 = 0; |
|
| 36 |
mSignature3 = type.ordinal(); |
|
| 68 |
mSignature = new long[SIZE]; |
|
| 69 |
mSignature[SIZE-1] = type.ordinal(); |
|
| 37 | 70 |
} |
| 38 | 71 |
|
| 39 | 72 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 40 | 73 |
|
| 41 | 74 |
public ObjectSignature(ObjectSignature sig) |
| 42 | 75 |
{
|
| 43 |
mSignature1 = sig.mSignature1;
|
|
| 44 |
mSignature2 = sig.mSignature2;
|
|
| 45 |
mSignature3 = sig.mSignature3;
|
|
| 76 |
int len = sig.mSignature.length;
|
|
| 77 |
mSignature = new long[len];
|
|
| 78 |
for(int i=0; i<len; i++) mSignature[i] = sig.mSignature[i];
|
|
| 46 | 79 |
|
| 47 | 80 |
mLayer = sig.mLayer; |
| 48 | 81 |
mCycles = sig.mCycles; |
| 49 | 82 |
mCubitTouch = sig.mCubitTouch; |
| 83 |
mName = sig.mName; |
|
| 50 | 84 |
|
| 51 | 85 |
mNumCubitTouches = sig.mNumCubitTouches; |
| 52 | 86 |
mNumCentCyclesPerLayer = sig.mNumCentCyclesPerLayer; |
| ... | ... | |
| 59 | 93 |
|
| 60 | 94 |
public ObjectSignature(long signature) |
| 61 | 95 |
{
|
| 62 |
mSignature1 = 0; |
|
| 63 |
mSignature2 = 0; |
|
| 64 |
mSignature3 = signature; |
|
| 96 |
mSignature = new long[SIZE]; |
|
| 97 |
mSignature[SIZE-1] = signature; |
|
| 65 | 98 |
} |
| 66 | 99 |
|
| 67 | 100 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 68 | 101 |
// locally created bandaged cuboids created from JSON (version2) |
| 69 | 102 |
|
| 70 |
public ObjectSignature(String shortName, long signature1, long signature2, long signature3)
|
|
| 103 |
public ObjectSignature(String shortName, long[] signature)
|
|
| 71 | 104 |
{
|
| 72 |
mSignature1 = signature1; |
|
| 73 |
mSignature2 = signature2; |
|
| 74 |
mSignature3 = signature3; |
|
| 105 |
setUpSignature(signature); |
|
| 75 | 106 |
|
| 76 | 107 |
int x = shortName.charAt(0) - '0'; |
| 77 | 108 |
int y = shortName.charAt(1) - '0'; |
| ... | ... | |
| 86 | 117 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 87 | 118 |
// other objects created from JSON (version2) |
| 88 | 119 |
|
| 89 |
public ObjectSignature(long signature1, long signature2, long signature3)
|
|
| 120 |
public ObjectSignature(long[] signature)
|
|
| 90 | 121 |
{
|
| 91 |
mSignature1 = signature1; |
|
| 92 |
mSignature2 = signature2; |
|
| 93 |
mSignature3 = signature3; |
|
| 122 |
setUpSignature(signature); |
|
| 94 | 123 |
} |
| 95 | 124 |
|
| 96 | 125 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 101 | 130 |
public ObjectSignature(int lenx, int leny, int lenz, float[][] position) |
| 102 | 131 |
{
|
| 103 | 132 |
mLayer = new int[] {lenx,leny,lenz};
|
| 133 |
mSignature = new long[SIZE]; |
|
| 104 | 134 |
|
| 105 | 135 |
prepareCubitTouch(); |
| 106 | 136 |
prepareAllCycles(); |
| ... | ... | |
| 137 | 167 |
|
| 138 | 168 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 139 | 169 |
|
| 140 |
public void setSignature(ObjectSignature sig) |
|
| 141 |
{
|
|
| 142 |
mSignature1 = sig.mSignature1; |
|
| 143 |
mSignature2 = sig.mSignature2; |
|
| 144 |
mSignature3 = sig.mSignature3; |
|
| 145 |
} |
|
| 146 |
|
|
| 147 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 148 |
|
|
| 149 |
public void setSignature(int sig) |
|
| 170 |
public void setSignature(int signature) |
|
| 150 | 171 |
{
|
| 151 |
mSignature1 = 0; |
|
| 152 |
mSignature2 = 0; |
|
| 153 |
mSignature3 = sig; |
|
| 172 |
for(int i=0; i<SIZE-1; i++) mSignature[i]=0; |
|
| 173 |
mSignature[SIZE-1] = signature; |
|
| 154 | 174 |
} |
| 155 | 175 |
|
| 156 | 176 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 157 | 177 |
|
| 158 | 178 |
public int compareTo(ObjectSignature sig) |
| 159 | 179 |
{
|
| 160 |
if( mSignature1>sig.mSignature1 ) return +1; |
|
| 161 |
else if( mSignature1<sig.mSignature1 ) return -1; |
|
| 162 |
else |
|
| 180 |
for(int i=0; i<SIZE; i++) |
|
| 163 | 181 |
{
|
| 164 |
if( mSignature2>sig.mSignature2 ) return +1; |
|
| 165 |
else if( mSignature2<sig.mSignature2 ) return -1; |
|
| 166 |
else |
|
| 167 |
{
|
|
| 168 |
if( mSignature3>sig.mSignature3 ) return +1; |
|
| 169 |
else if( mSignature3<sig.mSignature3 ) return -1; |
|
| 170 |
else return 0; |
|
| 171 |
} |
|
| 182 |
long diff = mSignature[i] - sig.mSignature[i]; |
|
| 183 |
|
|
| 184 |
if( diff>0 ) return +1; |
|
| 185 |
else if( diff<0 ) return -1; |
|
| 172 | 186 |
} |
| 187 |
|
|
| 188 |
return 0; |
|
| 173 | 189 |
} |
| 174 | 190 |
|
| 175 | 191 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 176 | 192 |
|
| 177 | 193 |
public boolean isEqual(ObjectSignature sig) |
| 178 | 194 |
{
|
| 179 |
return mSignature1==sig.mSignature1 && mSignature2==sig.mSignature2 && mSignature3==sig.mSignature3;
|
|
| 180 |
}
|
|
| 181 |
|
|
| 182 |
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
| 195 |
for(int i=0; i<SIZE; i++)
|
|
| 196 |
{
|
|
| 197 |
if( mSignature[i] != sig.mSignature[i] ) return false; |
|
| 198 |
}
|
|
| 183 | 199 |
|
| 184 |
public long getLong1() |
|
| 185 |
{
|
|
| 186 |
return mSignature1; |
|
| 200 |
return true; |
|
| 187 | 201 |
} |
| 188 | 202 |
|
| 189 | 203 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 190 | 204 |
|
| 191 |
public long getLong2()
|
|
| 205 |
public long[] getArray()
|
|
| 192 | 206 |
{
|
| 193 |
return mSignature2;
|
|
| 207 |
return mSignature; |
|
| 194 | 208 |
} |
| 195 | 209 |
|
| 196 | 210 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 197 | 211 |
|
| 198 |
public long getLong3()
|
|
| 212 |
public String getString()
|
|
| 199 | 213 |
{
|
| 200 |
return mSignature3; |
|
| 201 |
} |
|
| 214 |
if( mName==null ) |
|
| 215 |
{
|
|
| 216 |
StringBuilder sb = new StringBuilder(); |
|
| 202 | 217 |
|
| 203 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 218 |
for(int i=0; i<SIZE; i++) |
|
| 219 |
{
|
|
| 220 |
String sig = String.format("0x%016X", mSignature[i]);
|
|
| 221 |
if( i>0 ) sb.append('_');
|
|
| 222 |
sb.append(sig); |
|
| 223 |
} |
|
| 204 | 224 |
|
| 205 |
public String getString() |
|
| 206 |
{
|
|
| 207 |
String sig1 = String.format("0x%016X", mSignature1);
|
|
| 208 |
String sig2 = String.format("0x%016X", mSignature2);
|
|
| 209 |
String sig3 = String.format("0x%016X", mSignature3);
|
|
| 225 |
mName = sb.toString(); |
|
| 226 |
} |
|
| 210 | 227 |
|
| 211 |
return sig1+"_"+sig2+"_"+sig3;
|
|
| 228 |
return mName;
|
|
| 212 | 229 |
} |
| 213 | 230 |
|
| 214 | 231 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 561 | 578 |
|
| 562 | 579 |
private long getBit(int index) |
| 563 | 580 |
{
|
| 564 |
switch(index/64) |
|
| 565 |
{
|
|
| 566 |
case 0: return (mSignature3>>(index%64))&0x1; |
|
| 567 |
case 1: return (mSignature2>>(index%64))&0x1; |
|
| 568 |
case 2: return (mSignature1>>(index%64))&0x1; |
|
| 569 |
default: android.util.Log.e("D", "error in getBit, index="+index);
|
|
| 570 |
} |
|
| 571 |
|
|
| 572 |
return 0L; |
|
| 581 |
int sigIndex = SIZE-1-(index/64); |
|
| 582 |
return (mSignature[sigIndex]>>(index%64))&0x1; |
|
| 573 | 583 |
} |
| 574 | 584 |
|
| 575 | 585 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 576 | 586 |
|
| 577 | 587 |
private void setBit(int index, long bit) |
| 578 | 588 |
{
|
| 579 |
long diff = (1L<<(index%64)); |
|
| 580 |
|
|
| 581 |
switch(index/64) |
|
| 582 |
{
|
|
| 583 |
case 0: if( bit!=0 ) mSignature3 |= diff; |
|
| 584 |
else mSignature3 &=~diff; |
|
| 585 |
break; |
|
| 586 |
case 1: if( bit!=0 ) mSignature2 |= diff; |
|
| 587 |
else mSignature2 &=~diff; |
|
| 588 |
break; |
|
| 589 |
case 2: if( bit!=0 ) mSignature1 |= diff; |
|
| 590 |
else mSignature1 &=~diff; |
|
| 591 |
break; |
|
| 592 |
default: android.util.Log.e("D", "error in setBit, index="+index);
|
|
| 593 |
} |
|
| 589 |
long diff = (1L<<(index%64)); |
|
| 590 |
int sigIndex = SIZE-1-(index/64); |
|
| 591 |
if( bit!=0 ) mSignature[sigIndex] |= diff; |
|
| 592 |
else mSignature[sigIndex] &=~diff; |
|
| 594 | 593 |
} |
| 595 | 594 |
} |
| src/main/java/org/distorted/objectlib/json/JsonReader.java | ||
|---|---|---|
| 139 | 139 |
long signature1 = object.getLong("signature1");
|
| 140 | 140 |
long signature2 = object.getLong("signature2");
|
| 141 | 141 |
long signature3 = object.getLong("signature3");
|
| 142 |
long[] signature= new long[] {signature1,signature2,signature3};
|
|
| 142 | 143 |
|
| 143 | 144 |
switch( TwistyBandagedCuboid.getType(mShortName,mLongName) ) |
| 144 | 145 |
{
|
| 145 |
case 0: mSignature = new ObjectSignature(signature1,signature2,signature3); break; |
|
| 146 |
case 1: mSignature = new ObjectSignature(mShortName,signature1,signature2,signature3); break; |
|
| 147 |
case 2: mSignature = new ObjectSignature("333",signature1,signature2,signature3); break;
|
|
| 146 |
case 0: mSignature = new ObjectSignature(signature); break; |
|
| 147 |
case 1: mSignature = new ObjectSignature(mShortName,signature); break; |
|
| 148 |
case 2: mSignature = new ObjectSignature("333",signature); break;
|
|
| 149 |
} |
|
| 150 |
} |
|
| 151 |
catch(JSONException ex) |
|
| 152 |
{
|
|
| 153 |
long signature = object.getLong("signature");
|
|
| 154 |
mSignature = new ObjectSignature(signature); |
|
| 155 |
} |
|
| 156 |
} |
|
| 157 |
|
|
| 158 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 159 |
|
|
| 160 |
private void parseMetadata5(JSONObject object) throws JSONException |
|
| 161 |
{
|
|
| 162 |
mLongName = object.getString("longname");
|
|
| 163 |
mShortName = object.getString("shortname");
|
|
| 164 |
mInventor = object.getString("inventor");
|
|
| 165 |
mYearOfInvention = object.getInt("year");
|
|
| 166 |
mComplexity = object.getInt("complexity");
|
|
| 167 |
mSize = (float)object.getDouble("size");
|
|
| 168 |
mNumScrambles = object.getInt("scrambles");
|
|
| 169 |
mResetMaps = object.getBoolean("resetmaps");
|
|
| 170 |
mNumFaces = object.getInt("num_faces");
|
|
| 171 |
|
|
| 172 |
try |
|
| 173 |
{
|
|
| 174 |
JSONArray sigArray = object.getJSONArray("signature");
|
|
| 175 |
int size = sigArray.length(); |
|
| 176 |
long[] signature = new long[size]; |
|
| 177 |
for(int i=0; i<size; i++) signature[i] = sigArray.getLong(i); |
|
| 178 |
|
|
| 179 |
switch( TwistyBandagedCuboid.getType(mShortName,mLongName) ) |
|
| 180 |
{
|
|
| 181 |
case 0: mSignature = new ObjectSignature(signature); break; |
|
| 182 |
case 1: mSignature = new ObjectSignature(mShortName,signature); break; |
|
| 183 |
case 2: mSignature = new ObjectSignature("333",signature); break;
|
|
| 148 | 184 |
} |
| 149 | 185 |
} |
| 150 | 186 |
catch(JSONException ex) |
| ... | ... | |
| 446 | 482 |
|
| 447 | 483 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 448 | 484 |
|
| 449 |
private void parseAxis2or3or4(JSONArray object) throws JSONException |
|
| 485 |
private void parseAxis2or3or4or5(JSONArray object) throws JSONException
|
|
| 450 | 486 |
{
|
| 451 | 487 |
int numAxis = object.length(); |
| 452 | 488 |
|
| ... | ... | |
| 652 | 688 |
JSONObject mesh = object.getJSONObject("mesh");
|
| 653 | 689 |
parseMesh(mesh); |
| 654 | 690 |
JSONArray axis = object.getJSONArray("axis");
|
| 655 |
parseAxis2or3or4(axis); |
|
| 691 |
parseAxis2or3or4or5(axis); |
|
| 692 |
JSONArray quats = object.getJSONArray("quats");
|
|
| 693 |
parseQuats(quats); |
|
| 694 |
JSONObject scrambling = object.getJSONObject("scrambling");
|
|
| 695 |
parseScrambling(scrambling); |
|
| 696 |
JSONObject touchcontrol= object.getJSONObject("touchcontrol");
|
|
| 697 |
parseTouchcontrol(touchcontrol); |
|
| 698 |
JSONArray colors = object.getJSONArray("colors");
|
|
| 699 |
parseColors(colors); |
|
| 700 |
JSONObject solved = object.getJSONObject("solved");
|
|
| 701 |
parseSolved(solved); |
|
| 702 |
} |
|
| 703 |
|
|
| 704 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 705 |
|
|
| 706 |
private void parseVersion5(JSONObject object) throws JSONException |
|
| 707 |
{
|
|
| 708 |
JSONObject metadata = object.getJSONObject("metadata");
|
|
| 709 |
parseMetadata5(metadata); |
|
| 710 |
JSONObject mesh = object.getJSONObject("mesh");
|
|
| 711 |
parseMesh(mesh); |
|
| 712 |
JSONArray axis = object.getJSONArray("axis");
|
|
| 713 |
parseAxis2or3or4or5(axis); |
|
| 656 | 714 |
JSONArray quats = object.getJSONArray("quats");
|
| 657 | 715 |
parseQuats(quats); |
| 658 | 716 |
JSONObject scrambling = object.getJSONObject("scrambling");
|
| ... | ... | |
| 701 | 759 |
parseMetadata2or3or4(metadata); |
| 702 | 760 |
} |
| 703 | 761 |
|
| 762 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 763 |
|
|
| 764 |
private void parseVersion5Metadata(JSONObject object) throws JSONException |
|
| 765 |
{
|
|
| 766 |
JSONObject metadata = object.getJSONObject("metadata");
|
|
| 767 |
parseMetadata5(metadata); |
|
| 768 |
} |
|
| 769 |
|
|
| 704 | 770 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 705 | 771 |
|
| 706 | 772 |
public void parseJsonFile(InputStream jsonStream) throws JSONException, IOException |
| ... | ... | |
| 724 | 790 |
{
|
| 725 | 791 |
parseVersion2or3or4(object); |
| 726 | 792 |
} |
| 793 |
else if( major==5 ) |
|
| 794 |
{
|
|
| 795 |
parseVersion5(object); |
|
| 796 |
} |
|
| 727 | 797 |
else |
| 728 | 798 |
{
|
| 729 | 799 |
android.util.Log.e("readJsonFile", "Unknown version "+major);
|
| ... | ... | |
| 753 | 823 |
{
|
| 754 | 824 |
parseVersion2or3or4Metadata(object); |
| 755 | 825 |
} |
| 826 |
else if( major==5 ) |
|
| 827 |
{
|
|
| 828 |
parseVersion5Metadata(object); |
|
| 829 |
} |
|
| 756 | 830 |
else |
| 757 | 831 |
{
|
| 758 | 832 |
android.util.Log.e("readJsonFileQuick", "Unknown version "+major);
|
| src/main/java/org/distorted/objectlib/json/JsonWriter.java | ||
|---|---|---|
| 16 | 16 |
import java.nio.charset.StandardCharsets; |
| 17 | 17 |
|
| 18 | 18 |
import org.distorted.objectlib.helpers.ObjectFaceShape; |
| 19 |
import org.distorted.objectlib.helpers.ObjectSignature; |
|
| 20 | 19 |
import org.distorted.objectlib.helpers.ObjectStickerOverride; |
| 21 | 20 |
import org.json.JSONArray; |
| 22 | 21 |
import org.json.JSONException; |
| ... | ... | |
| 34 | 33 |
|
| 35 | 34 |
public class JsonWriter |
| 36 | 35 |
{
|
| 37 |
public static final int VERSION_OBJECT_MAJOR = 4;
|
|
| 36 |
public static final int VERSION_OBJECT_MAJOR = 5;
|
|
| 38 | 37 |
public static final int VERSION_OBJECT_MINOR = 0; |
| 39 | 38 |
public static final int VERSION_EXTRAS_MAJOR = 1; |
| 40 | 39 |
public static final int VERSION_EXTRAS_MINOR = 0; |
| ... | ... | |
| 400 | 399 |
metadata.put("resetmaps" , object.shouldResetTextureMaps() );
|
| 401 | 400 |
metadata.put("num_faces" , object.getNumFaces() );
|
| 402 | 401 |
|
| 403 |
ObjectSignature signature = object.getSignature(); |
|
| 404 |
|
|
| 405 |
metadata.put("signature1" , signature.getLong1() );
|
|
| 406 |
metadata.put("signature2" , signature.getLong2() );
|
|
| 407 |
metadata.put("signature3" , signature.getLong3() );
|
|
| 402 |
JSONArray sigArray = new JSONArray(); |
|
| 403 |
long[] sig = object.getSignature().getArray(); |
|
| 404 |
for (long l : sig) sigArray.put(l); |
|
| 405 |
metadata.put("signature" , sigArray );
|
|
| 408 | 406 |
|
| 409 | 407 |
return metadata; |
| 410 | 408 |
} |
Also available in: Unified diff
Make ObjectSignature ready for any size bandaged cube.