Sweetgum/sweetgum-server
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reformat and clean up "tools" package

Browse Source
This commit is contained in:
P0nk
2021-09-09 23:28:07 +02:00
parent e8ef3a492c
commit 7be1d119de
19 changed files with 793 additions and 800 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/main/java/tools/ArrayMap.java
View File

@@ -21,12 +21,7 @@
*/ */
package tools; package tools;
import java.util.AbstractMap; import java.util.*;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class ArrayMap<K, V> extends AbstractMap<K, V> { public class ArrayMap<K, V> extends AbstractMap<K, V> {
@@ -77,8 +72,9 @@ public class ArrayMap<K, V> extends AbstractMap<K, V> {
return key + "=" + value; return key + "=" + value;
} }
} }
private Set<? extends java.util.Map.Entry<K, V>> entries = null; private Set<? extends java.util.Map.Entry<K, V>> entries = null;
private ArrayList<Entry<K, V>> list; private final ArrayList<Entry<K, V>> list;
public ArrayMap() { public ArrayMap() {
list = new ArrayList<>(); list = new ArrayList<>();
@@ -94,7 +90,7 @@ public class ArrayMap<K, V> extends AbstractMap<K, V> {
} }
@Override @Override
@SuppressWarnings ("unchecked") @SuppressWarnings("unchecked")
public Set<java.util.Map.Entry<K, V>> entrySet() { public Set<java.util.Map.Entry<K, V>> entrySet() {
if (entries == null) { if (entries == null) {
entries = new AbstractSet<Entry<K, V>>() { entries = new AbstractSet<Entry<K, V>>() {

794
src/main/java/tools/BCrypt.java
View File

@@ -13,7 +13,7 @@
// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
package tools; package tools;
import java.io.UnsupportedEncodingException; import java.nio.charset.StandardCharsets;
import java.security.SecureRandom; import java.security.SecureRandom;
import java.util.Arrays; import java.util.Arrays;
@@ -69,301 +69,301 @@ public class BCrypt {
private static final int BLOWFISH_NUM_ROUNDS = 16; private static final int BLOWFISH_NUM_ROUNDS = 16;
// Initial contents of key schedule // Initial contents of key schedule
private static final int[] P_orig = { private static final int[] P_orig = {
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
0x9216d5d9, 0x8979fb1b 0x9216d5d9, 0x8979fb1b
}; };
private static final int[] S_orig = { private static final int[] S_orig = {
0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a, 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a,
0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7, 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7,
0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0, 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0,
0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
}; };
// bcrypt IV: "OrpheanBeholderScryDoubt". The C implementation calls // bcrypt IV: "OrpheanBeholderScryDoubt". The C implementation calls
// this "ciphertext", but it is really plaintext or an IV. We keep // this "ciphertext", but it is really plaintext or an IV. We keep
// the name to make code comparison easier. // the name to make code comparison easier.
static private final int[] bf_crypt_ciphertext = { static private final int[] bf_crypt_ciphertext = {
0x4f727068, 0x65616e42, 0x65686f6c, 0x4f727068, 0x65616e42, 0x65686f6c,
0x64657253, 0x63727944, 0x6f756274 0x64657253, 0x63727944, 0x6f756274
}; };
// Table for Base64 encoding // Table for Base64 encoding
static private final char[] base64_code = { static private final char[] base64_code = {
'.', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', '.', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',
'6', '7', '8', '9' '6', '7', '8', '9'
}; };
// Table for Base64 decoding // Table for Base64 decoding
static private final byte[] index_64 = { static private final byte[] index_64 = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 0, 1, 54, 55, -1, -1, -1, -1, -1, -1, 0, 1, 54, 55,
56, 57, 58, 59, 60, 61, 62, 63, -1, -1, 56, 57, 58, 59, 60, 61, 62, 63, -1, -1,
-1, -1, -1, -1, -1, 2, 3, 4, 5, 6, -1, -1, -1, -1, -1, 2, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
-1, -1, -1, -1, -1, -1, 28, 29, 30, -1, -1, -1, -1, -1, -1, 28, 29, 30,
31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
51, 52, 53, -1, -1, -1, -1, -1 51, 52, 53, -1, -1, -1, -1, -1
}; };
// Expanded Blowfish key // Expanded Blowfish key
private int[] P; private int[] P;
@@ -374,10 +374,10 @@ public class BCrypt {
* encoding scheme. Note that this is *not* compatible with * encoding scheme. Note that this is *not* compatible with
* the standard MIME-base64 encoding. * the standard MIME-base64 encoding.
* *
* @param d the byte array to encode * @param d the byte array to encode
* @param len the number of bytes to encode * @param len the number of bytes to encode
* @return base64-encoded string * @throws IllegalArgumentException if the length is invalid
* @exception IllegalArgumentException if the length is invalid * @return base64-encoded string
*/ */
private static String encode_base64(byte[] d, int len) private static String encode_base64(byte[] d, int len)
throws IllegalArgumentException { throws IllegalArgumentException {
@@ -416,8 +416,9 @@ public class BCrypt {
/** /**
* Look up the 3 bits base64-encoded with the specified character, * Look up the 3 bits base64-encoded with the specified character,
* range-checking againt conversion table * range-checking againt conversion table
* @param x the base64-encoded value *
* @return the decoded value of x * @param x the base64-encoded value
* @return the decoded value of x
*/ */
private static byte char64(char x) { private static byte char64(char x) {
if ((int) x < 0 || (int) x > index_64.length) { if ((int) x < 0 || (int) x > index_64.length) {
@@ -430,10 +431,11 @@ public class BCrypt {
* Decode a string encoded using bcrypt's base64 scheme to a * Decode a string encoded using bcrypt's base64 scheme to a
* byte array. Note that this is *not* compatible with * byte array. Note that this is *not* compatible with
* the standard MIME-base64 encoding. * the standard MIME-base64 encoding.
* @param s the string to decode *
* @param maxolen the maximum number of bytes to decode * @param s the string to decode
* @return an array containing the bytes decoded * @param maxolen the maximum number of bytes to decode
* @throws IllegalArgumentException if maxolen is invalid * @throws IllegalArgumentException if maxolen is invalid
* @return an array containing the bytes decoded
*/ */
private static byte[] decode_base64(String s, int maxolen) private static byte[] decode_base64(String s, int maxolen)
throws IllegalArgumentException { throws IllegalArgumentException {
@@ -485,14 +487,15 @@ public class BCrypt {
/** /**
* Blowfish encipher a single 64-bit block encoded as * Blowfish encipher a single 64-bit block encoded as
* two 32-bit halves * two 32-bit halves
* @param lr an array containing the two 32-bit half blocks *
* @param off the position in the array of the blocks * @param lr an array containing the two 32-bit half blocks
* @param off the position in the array of the blocks
*/ */
private final void encipher(int[] lr, int off) { private final void encipher(int[] lr, int off) {
int i, n, l = lr[off], r = lr[off + 1]; int i, n, l = lr[off], r = lr[off + 1];
l ^= P[0]; l ^= P[0];
for (i = 0; i <= BLOWFISH_NUM_ROUNDS - 2;) { for (i = 0; i <= BLOWFISH_NUM_ROUNDS - 2; ) {
// Feistel substitution on left word // Feistel substitution on left word
n = S[(l >> 24) & 0xff]; n = S[(l >> 24) & 0xff];
n += S[0x100 | ((l >> 16) & 0xff)]; n += S[0x100 | ((l >> 16) & 0xff)];
@@ -513,23 +516,26 @@ public class BCrypt {
/** /**
* Cycically extract a word of key material * Cycically extract a word of key material
* @param data the string to extract the data from *
* @param offp a "pointer" (as a one-entry array) to the * @param data the string to extract the data from
* current offset into data * @param offp a "pointer" (as a one-entry array) to the
* @param signp a "pointer" (as a one-entry array) to the * current offset into data
* cumulative flag for non-benign sign extension * @param signp a "pointer" (as a one-entry array) to the
* @return correct and buggy next word of material from data as int[2] * cumulative flag for non-benign sign extension
* @return correct and buggy next word of material from data as int[2]
*/ */
private static int[] streamtowords(byte[] data, int[] offp, int[] signp) { private static int[] streamtowords(byte[] data, int[] offp, int[] signp) {
int i; int i;
int[] words = { 0, 0 }; int[] words = {0, 0};
int off = offp[0]; int off = offp[0];
int sign = signp[0]; int sign = signp[0];
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
words[0] = (words[0] << 8) | (data[off] & 0xff); words[0] = (words[0] << 8) | (data[off] & 0xff);
words[1] = (words[1] << 8) | (int)data[off]; words[1] = (words[1] << 8) | (int) data[off];
if (i > 0) sign |= words[1] & 0x80; if (i > 0) {
sign |= words[1] & 0x80;
}
off = (off + 1) % data.length; off = (off + 1) % data.length;
} }
@@ -540,25 +546,27 @@ public class BCrypt {
/** /**
* Cycically extract a word of key material * Cycically extract a word of key material
* @param data the string to extract the data from *
* @param offp a "pointer" (as a one-entry array) to the * @param data the string to extract the data from
* current offset into data * @param offp a "pointer" (as a one-entry array) to the
* @return the next word of material from data * current offset into data
* @return the next word of material from data
*/ */
private static int streamtoword(byte[] data, int[] offp) { private static int streamtoword(byte[] data, int[] offp) {
int[] signp = { 0 }; int[] signp = {0};
return streamtowords(data, offp, signp)[0]; return streamtowords(data, offp, signp)[0];
} }
/** /**
* Cycically extract a word of key material, with sign-extension bug * Cycically extract a word of key material, with sign-extension bug
* @param data the string to extract the data from *
* @param offp a "pointer" (as a one-entry array) to the * @param data the string to extract the data from
* current offset into data * @param offp a "pointer" (as a one-entry array) to the
* @return the next word of material from data * current offset into data
* @return the next word of material from data
*/ */
private static int streamtoword_bug(byte[] data, int[] offp) { private static int streamtoword_bug(byte[] data, int[] offp) {
int[] signp = { 0 }; int[] signp = {0};
return streamtowords(data, offp, signp)[1]; return streamtowords(data, offp, signp)[1];
} }
@@ -572,8 +580,9 @@ public class BCrypt {
/** /**
* Key the Blowfish cipher * Key the Blowfish cipher
* @param key an array containing the key *
* @param sign_ext_bug true to implement the 2x bug * @param key an array containing the key
* @param sign_ext_bug true to implement the 2x bug
*/ */
private void key(byte[] key, boolean sign_ext_bug) { private void key(byte[] key, boolean sign_ext_bug) {
int i; int i;
@@ -582,10 +591,11 @@ public class BCrypt {
int plen = P.length, slen = S.length; int plen = P.length, slen = S.length;
for (i = 0; i < plen; i++) { for (i = 0; i < plen; i++) {
if (!sign_ext_bug) if (!sign_ext_bug) {
P[i] = P[i] ^ streamtoword(key, koffp); P[i] = P[i] ^ streamtoword(key, koffp);
else } else {
P[i] = P[i] ^ streamtoword_bug(key, koffp); P[i] = P[i] ^ streamtoword_bug(key, koffp);
}
} }
for (i = 0; i < plen; i += 2) { for (i = 0; i < plen; i += 2) {
@@ -605,10 +615,11 @@ public class BCrypt {
* Perform the "enhanced key schedule" step described by * Perform the "enhanced key schedule" step described by
* Provos and Mazieres in "A Future-Adaptable Password Scheme" * Provos and Mazieres in "A Future-Adaptable Password Scheme"
* http://www.openbsd.org/papers/bcrypt-paper.ps * http://www.openbsd.org/papers/bcrypt-paper.ps
* @param data salt information *
* @param key password information * @param data salt information
* @param sign_ext_bug true to implement the 2x bug * @param key password information
* @param safety bit 16 is set when the safety measure is requested * @param sign_ext_bug true to implement the 2x bug
* @param safety bit 16 is set when the safety measure is requested
*/ */
private void ekskey(byte[] data, byte[] key, private void ekskey(byte[] data, byte[] key,
boolean sign_ext_bug, int safety) { boolean sign_ext_bug, int safety) {
@@ -616,7 +627,7 @@ public class BCrypt {
int[] koffp = {0}, doffp = {0}; int[] koffp = {0}, doffp = {0};
int[] lr = {0, 0}; int[] lr = {0, 0};
int plen = P.length, slen = S.length; int plen = P.length, slen = S.length;
int[] signp = { 0 }; // non-benign sign-extension flag int[] signp = {0}; // non-benign sign-extension flag
int diff = 0; // zero iff correct and buggy are same int diff = 0; // zero iff correct and buggy are same
for (i = 0; i < plen; i++) { for (i = 0; i < plen; i++) {
@@ -675,14 +686,15 @@ public class BCrypt {
/** /**
* Perform the central password hashing step in the * Perform the central password hashing step in the
* bcrypt scheme * bcrypt scheme
* @param password the password to hash *
* @param salt the binary salt to hash with the password * @param password the password to hash
* @param log_rounds the binary logarithm of the number * @param salt the binary salt to hash with the password
* of rounds of hashing to apply * @param log_rounds the binary logarithm of the number
* @param sign_ext_bug true to implement the 2x bug * of rounds of hashing to apply
* @param safety bit 16 is set when the safety measure is requested * @param sign_ext_bug true to implement the 2x bug
* @param cdata the plaintext to encrypt * @param safety bit 16 is set when the safety measure is requested
* @return an array containing the binary hashed password * @param cdata the plaintext to encrypt
* @return an array containing the binary hashed password
*/ */
private byte[] crypt_raw(byte[] password, byte[] salt, int log_rounds, private byte[] crypt_raw(byte[] password, byte[] salt, int log_rounds,
boolean sign_ext_bug, int safety, int[] cdata) { boolean sign_ext_bug, int safety, int[] cdata) {
@@ -723,27 +735,25 @@ public class BCrypt {
/** /**
* Converts given plaintext to byte representation. * Converts given plaintext to byte representation.
* @param plaintext the plaintext password to convert *
* @param plaintext the plaintext password to convert
* @return Byte representation of given plaintext. * @return Byte representation of given plaintext.
*/ */
private static byte[] stringToBytes(String plaintext) { private static byte[] stringToBytes(String plaintext) {
byte[] plaintextb; byte[] plaintextb;
try { plaintextb = plaintext.getBytes(StandardCharsets.UTF_8);
plaintextb = plaintext.getBytes("UTF-8");
} catch (UnsupportedEncodingException uee) {
throw new AssertionError("UTF-8 is not supported");
}
return plaintextb; return plaintextb;
} }
/** /**
* Hash a password using the OpenBSD bcrypt scheme * Hash a password using the OpenBSD bcrypt scheme
* @param password the password to hash *
* @param salt the salt to hash with (perhaps generated * @param password the password to hash
* using BCrypt.gensalt) * @param salt the salt to hash with (perhaps generated
* @return the hashed password * using BCrypt.gensalt)
* @return the hashed password
*/ */
public static String hashpw(String password, String salt) { public static String hashpw(String password, String salt) {
byte[] passwordb = stringToBytes(password); byte[] passwordb = stringToBytes(password);
@@ -753,10 +763,11 @@ public class BCrypt {
/** /**
* Hash a password using the OpenBSD bcrypt scheme * Hash a password using the OpenBSD bcrypt scheme
* @param passwordb the password to hash, as a byte array *
* @param salt the salt to hash with (perhaps generated * @param passwordb the password to hash, as a byte array
* using BCrypt.gensalt) * @param salt the salt to hash with (perhaps generated
* @return the hashed password * using BCrypt.gensalt)
* @return the hashed password
*/ */
public static String hashpw(byte[] passwordb, String salt) { public static String hashpw(byte[] passwordb, String salt) {
BCrypt B; BCrypt B;
@@ -791,7 +802,9 @@ public class BCrypt {
saltb = decode_base64(real_salt, BCRYPT_SALT_LEN); saltb = decode_base64(real_salt, BCRYPT_SALT_LEN);
if (minor >= 'a') // add null terminator if (minor >= 'a') // add null terminator
{
passwordb = Arrays.copyOf(passwordb, passwordb.length + 1); passwordb = Arrays.copyOf(passwordb, passwordb.length + 1);
}
B = new BCrypt(); B = new BCrypt();
hashed = B.crypt_raw(passwordb, saltb, rounds, hashed = B.crypt_raw(passwordb, saltb, rounds,
@@ -821,13 +834,14 @@ public class BCrypt {
/** /**
* Generate a salt for use with the BCrypt.hashpw() method * Generate a salt for use with the BCrypt.hashpw() method
* @param prefix the prefix value (default $2y) *
* @param log_rounds the log2 of the number of rounds of * @param prefix the prefix value (default $2y)
* hashing to apply - the work factor therefore increases as * @param log_rounds the log2 of the number of rounds of
* 2**log_rounds. * hashing to apply - the work factor therefore increases as
* @param random an instance of SecureRandom to use * 2**log_rounds.
* @return an encoded salt value * @param random an instance of SecureRandom to use
* @exception IllegalArgumentException if prefix or log_rounds is invalid * @throws IllegalArgumentException if prefix or log_rounds is invalid
* @return an encoded salt value
*/ */
public static String gensalt(String prefix, int log_rounds, SecureRandom random) public static String gensalt(String prefix, int log_rounds, SecureRandom random)
throws IllegalArgumentException { throws IllegalArgumentException {
@@ -836,11 +850,11 @@ public class BCrypt {
if (!prefix.startsWith("$2") || if (!prefix.startsWith("$2") ||
(prefix.charAt(2) != 'a' && prefix.charAt(2) != 'y') && (prefix.charAt(2) != 'a' && prefix.charAt(2) != 'y') &&
prefix.charAt(2) != 'b') { prefix.charAt(2) != 'b') {
throw new IllegalArgumentException ("Invalid prefix"); throw new IllegalArgumentException("Invalid prefix");
} }
if (log_rounds < 4 || log_rounds > 31) { if (log_rounds < 4 || log_rounds > 31) {
throw new IllegalArgumentException ("Invalid log_rounds"); throw new IllegalArgumentException("Invalid log_rounds");
} }
random.nextBytes(rnd); random.nextBytes(rnd);
@@ -863,12 +877,13 @@ public class BCrypt {
/** /**
* Generate a salt for use with the BCrypt.hashpw() method * Generate a salt for use with the BCrypt.hashpw() method
* @param prefix the prefix value (default $2y) *
* @param log_rounds the log2 of the number of rounds of * @param prefix the prefix value (default $2y)
* hashing to apply - the work factor therefore increases as * @param log_rounds the log2 of the number of rounds of
* 2**log_rounds. * hashing to apply - the work factor therefore increases as
* @return an encoded salt value * 2**log_rounds.
* @exception IllegalArgumentException if prefix or log_rounds is invalid * @throws IllegalArgumentException if prefix or log_rounds is invalid
* @return an encoded salt value
*/ */
public static String gensalt(String prefix, int log_rounds) public static String gensalt(String prefix, int log_rounds)
throws IllegalArgumentException { throws IllegalArgumentException {
@@ -877,12 +892,13 @@ public class BCrypt {
/** /**
* Generate a salt for use with the BCrypt.hashpw() method * Generate a salt for use with the BCrypt.hashpw() method
* @param log_rounds the log2 of the number of rounds of *
* hashing to apply - the work factor therefore increases as * @param log_rounds the log2 of the number of rounds of
* 2**log_rounds. * hashing to apply - the work factor therefore increases as
* @param random an instance of SecureRandom to use * 2**log_rounds.
* @return an encoded salt value * @param random an instance of SecureRandom to use
* @exception IllegalArgumentException if prefix or log_rounds is invalid * @throws IllegalArgumentException if prefix or log_rounds is invalid
* @return an encoded salt value
*/ */
public static String gensalt(int log_rounds, SecureRandom random) public static String gensalt(int log_rounds, SecureRandom random)
throws IllegalArgumentException { throws IllegalArgumentException {
@@ -891,11 +907,12 @@ public class BCrypt {
/** /**
* Generate a salt for use with the BCrypt.hashpw() method * Generate a salt for use with the BCrypt.hashpw() method
* @param log_rounds the log2 of the number of rounds of *
* hashing to apply - the work factor therefore increases as * @param log_rounds the log2 of the number of rounds of
* 2**log_rounds. * hashing to apply - the work factor therefore increases as
* @return an encoded salt value * 2**log_rounds.
* @exception IllegalArgumentException if prefix or log_rounds is invalid * @throws IllegalArgumentException if prefix or log_rounds is invalid
* @return an encoded salt value
*/ */
public static String gensalt(int log_rounds) public static String gensalt(int log_rounds)
throws IllegalArgumentException { throws IllegalArgumentException {
@@ -906,8 +923,9 @@ public class BCrypt {
* Generate a salt for use with the BCrypt.hashpw() method, * Generate a salt for use with the BCrypt.hashpw() method,
* selecting a reasonable default for the number of hashing * selecting a reasonable default for the number of hashing
* rounds to apply * rounds to apply
* @return an encoded salt value *
* @exception IllegalArgumentException if prefix or log_rounds is invalid * @throws IllegalArgumentException if prefix or log_rounds is invalid
* @return an encoded salt value
*/ */
public static String gensalt() public static String gensalt()
throws IllegalArgumentException { throws IllegalArgumentException {
@@ -917,9 +935,10 @@ public class BCrypt {
/** /**
* Check that a plaintext password matches a previously hashed * Check that a plaintext password matches a previously hashed
* one * one
* @param plaintext the plaintext password to verify *
* @param hashed the previously-hashed password * @param plaintext the plaintext password to verify
* @return true if the passwords match, false otherwise * @param hashed the previously-hashed password
* @return true if the passwords match, false otherwise
*/ */
public static boolean checkpw(String plaintext, String hashed) { public static boolean checkpw(String plaintext, String hashed) {
byte[] plaintextb = stringToBytes(plaintext); byte[] plaintextb = stringToBytes(plaintext);
@@ -929,25 +948,24 @@ public class BCrypt {
/** /**
* Check that a plaintext byte[] password matches a previously hashed * Check that a plaintext byte[] password matches a previously hashed
* one * one
* @param plaintext the plaintext password to verify *
* @param hashed the previously-hashed password * @param plaintext the plaintext password to verify
* @return true if the passwords match, false otherwise * @param hashed the previously-hashed password
* @return true if the passwords match, false otherwise
*/ */
public static boolean checkpw(byte[] plaintext, String hashed) { public static boolean checkpw(byte[] plaintext, String hashed) {
byte[] hashed_bytes; byte[] hashed_bytes;
byte[] try_bytes; byte[] try_bytes;
try { String try_pw = hashpw(plaintext, hashed);
String try_pw = hashpw(plaintext, hashed); hashed_bytes = hashed.getBytes(StandardCharsets.UTF_8);
hashed_bytes = hashed.getBytes("UTF-8"); try_bytes = try_pw.getBytes(StandardCharsets.UTF_8);
try_bytes = try_pw.getBytes("UTF-8"); if (hashed_bytes.length != try_bytes.length) {
} catch (UnsupportedEncodingException uee) {
return false; return false;
} }
if (hashed_bytes.length != try_bytes.length)
return false;
byte ret = 0; byte ret = 0;
for (int i = 0; i < try_bytes.length; i++) for (int i = 0; i < try_bytes.length; i++) {
ret |= hashed_bytes[i] ^ try_bytes[i]; ret |= hashed_bytes[i] ^ try_bytes[i];
}
return ret == 0; return ret == 0;
} }
} }

30
src/main/java/tools/FilePrinter.java
View File

@@ -1,16 +1,12 @@
package tools; package tools;
import java.io.File; import java.io.*;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.util.Calendar; import java.util.Calendar;
public class FilePrinter { public class FilePrinter {
public static final String public static final String
AUTOBAN_WARNING = "game/AutoBanWarning.txt", // log naming version by Vcoc AUTOBAN_WARNING = "game/AutoBanWarning.txt", // log naming version by Vcoc
AUTOBAN_DC = "game/AutoBanDC.txt", AUTOBAN_DC = "game/AutoBanDC.txt",
ACCOUNT_STUCK = "players/AccountStuck.txt", ACCOUNT_STUCK = "players/AccountStuck.txt",
@@ -70,16 +66,16 @@ public class FilePrinter {
DEADLOCK_LOCKS = "deadlocks/Locks.txt", DEADLOCK_LOCKS = "deadlocks/Locks.txt",
DEADLOCK_STATE = "deadlocks/State.txt", DEADLOCK_STATE = "deadlocks/State.txt",
DISPOSED_LOCKS = "deadlocks/Disposed.txt"; DISPOSED_LOCKS = "deadlocks/Disposed.txt";
private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); //for file system purposes, it's nice to use yyyy-MM-dd private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); //for file system purposes, it's nice to use yyyy-MM-dd
private static final String FILE_PATH = "logs/" + sdf.format(Calendar.getInstance().getTime()) + "/"; // + sdf.format(Calendar.getInstance().getTime()) + "/" private static final String FILE_PATH = "logs/" + sdf.format(Calendar.getInstance().getTime()) + "/"; // + sdf.format(Calendar.getInstance().getTime()) + "/"
private static final String ERROR = "error/"; private static final String ERROR = "error/";
public static void printError(final String name, final Throwable t) { public static void printError(final String name, final Throwable t) {
String stringT = getString(t); String stringT = getString(t);
System.out.println("Error thrown: " + name); System.out.println("Error thrown: " + name);
System.out.println(stringT); System.out.println(stringT);
System.out.println(); System.out.println();
FileOutputStream out = null; FileOutputStream out = null;
final String file = FILE_PATH + ERROR + name; final String file = FILE_PATH + ERROR + name;
@@ -107,9 +103,9 @@ public class FilePrinter {
public static void printError(final String name, final Throwable t, final String info) { public static void printError(final String name, final Throwable t, final String info) {
String stringT = getString(t); String stringT = getString(t);
System.out.println("Error thrown: " + name); System.out.println("Error thrown: " + name);
System.out.println(stringT); System.out.println(stringT);
System.out.println(); System.out.println();
FileOutputStream out = null; FileOutputStream out = null;
final String file = FILE_PATH + ERROR + name; final String file = FILE_PATH + ERROR + name;
@@ -137,8 +133,8 @@ public class FilePrinter {
} }
public static void printError(final String name, final String s) { public static void printError(final String name, final String s) {
System.out.println("Error thrown: " + name); System.out.println("Error thrown: " + name);
System.out.println(s); System.out.println(s);
System.out.println(); System.out.println();
FileOutputStream out = null; FileOutputStream out = null;
final String file = FILE_PATH + ERROR + name; final String file = FILE_PATH + ERROR + name;
@@ -169,8 +165,8 @@ public class FilePrinter {
} }
public static void print(final String name, final String s, boolean line) { public static void print(final String name, final String s, boolean line) {
System.out.println("Log: " + name); System.out.println("Log: " + name);
System.out.println(s); System.out.println(s);
System.out.println(); System.out.println();
FileOutputStream out = null; FileOutputStream out = null;
String file = FILE_PATH + name; String file = FILE_PATH + name;

2
src/main/java/tools/HexTool.java
View File

@@ -58,7 +58,7 @@ public class HexTool {
int nextb = 0; int nextb = 0;
boolean highoc = true; boolean highoc = true;
outer: outer:
for (;;) { for (; ; ) {
int number = -1; int number = -1;
while (number == -1) { while (number == -1) {
if (nexti == hex.length()) { if (nexti == hex.length()) {

17
src/main/java/tools/IntervalBuilder.java
View File

@@ -31,16 +31,15 @@ import java.util.ArrayList;
import java.util.List; import java.util.List;
/** /**
*
* @author Ronan * @author Ronan
*/ */
public class IntervalBuilder { public class IntervalBuilder {
private List<Line2D> intervalLimits = new ArrayList<>(); private final List<Line2D> intervalLimits = new ArrayList<>();
protected MonitoredReadLock intervalRlock; protected MonitoredReadLock intervalRlock;
protected MonitoredWriteLock intervalWlock; protected MonitoredWriteLock intervalWlock;
public IntervalBuilder() { public IntervalBuilder() {
MonitoredReentrantReadWriteLock locks = new MonitoredReentrantReadWriteLock(MonitoredLockType.INTERVAL, true); MonitoredReentrantReadWriteLock locks = new MonitoredReentrantReadWriteLock(MonitoredLockType.INTERVAL, true);
intervalRlock = MonitoredReadLockFactory.createLock(locks); intervalRlock = MonitoredReadLockFactory.createLock(locks);
@@ -100,7 +99,9 @@ public class IntervalBuilder {
} }
int en = bsearchInterval(to); int en = bsearchInterval(to);
if (en < st) en = st - 1; if (en < st) {
en = st - 1;
}
refitOverlappedIntervals(st, en + 1, from, to); refitOverlappedIntervals(st, en + 1, from, to);
} finally { } finally {
@@ -111,7 +112,7 @@ public class IntervalBuilder {
public boolean inInterval(int point) { public boolean inInterval(int point) {
return inInterval(point, point); return inInterval(point, point);
} }
public boolean inInterval(int from, int to) { public boolean inInterval(int from, int to) {
intervalRlock.lock(); intervalRlock.lock();
try { try {
@@ -130,5 +131,5 @@ public class IntervalBuilder {
intervalWlock.unlock(); intervalWlock.unlock();
} }
} }
} }

108
src/main/java/tools/LogHelper.java
View File

@@ -14,66 +14,66 @@ import java.util.Date;
public class LogHelper { public class LogHelper {
public static void logTrade(Trade trade1, Trade trade2) { public static void logTrade(Trade trade1, Trade trade2) {
String name1 = trade1.getChr().getName(); String name1 = trade1.getChr().getName();
String name2 = trade2.getChr().getName(); String name2 = trade2.getChr().getName();
String log = "TRADE BETWEEN " + name1 + " AND " + name2 + "\r\n"; String log = "TRADE BETWEEN " + name1 + " AND " + name2 + "\r\n";
//Trade 1 to trade 2 //Trade 1 to trade 2
log += trade1.getExchangeMesos() + " mesos from " + name1 + " to " + name2 + " \r\n"; log += trade1.getExchangeMesos() + " mesos from " + name1 + " to " + name2 + " \r\n";
for (Item item : trade1.getItems()){ for (Item item : trade1.getItems()) {
String itemName = ItemInformationProvider.getInstance().getName(item.getItemId()) + "(" + item.getItemId() + ")"; String itemName = ItemInformationProvider.getInstance().getName(item.getItemId()) + "(" + item.getItemId() + ")";
log += item.getQuantity() + " " + itemName + " from " + name1 + " to " + name2 + " \r\n"; log += item.getQuantity() + " " + itemName + " from " + name1 + " to " + name2 + " \r\n";
} }
//Trade 2 to trade 1 //Trade 2 to trade 1
log += trade2.getExchangeMesos() + " mesos from " + name2 + " to " + name1 + " \r\n"; log += trade2.getExchangeMesos() + " mesos from " + name2 + " to " + name1 + " \r\n";
for (Item item : trade2.getItems()){ for (Item item : trade2.getItems()) {
String itemName = ItemInformationProvider.getInstance().getName(item.getItemId()) + "(" + item.getItemId() + ")"; String itemName = ItemInformationProvider.getInstance().getName(item.getItemId()) + "(" + item.getItemId() + ")";
log += item.getQuantity() + " " + itemName + " from " + name2 + " to " + name1 + " \r\n"; log += item.getQuantity() + " " + itemName + " from " + name2 + " to " + name1 + " \r\n";
} }
log += "\r\n\r\n"; log += "\r\n\r\n";
FilePrinter.print(FilePrinter.LOG_TRADE, log); FilePrinter.print(FilePrinter.LOG_TRADE, log);
} }
public static void logExpedition(Expedition expedition) { public static void logExpedition(Expedition expedition) {
Server.getInstance().broadcastGMMessage(expedition.getLeader().getWorld(), PacketCreator.serverNotice(6, expedition.getType().toString() + " Expedition with leader " + expedition.getLeader().getName() + " finished after " + getTimeString(expedition.getStartTime()))); Server.getInstance().broadcastGMMessage(expedition.getLeader().getWorld(), PacketCreator.serverNotice(6, expedition.getType().toString() + " Expedition with leader " + expedition.getLeader().getName() + " finished after " + getTimeString(expedition.getStartTime())));
String log = expedition.getType().toString() + " EXPEDITION\r\n"; String log = expedition.getType().toString() + " EXPEDITION\r\n";
log += getTimeString(expedition.getStartTime()) + "\r\n"; log += getTimeString(expedition.getStartTime()) + "\r\n";
for (String memberName : expedition.getMembers().values()){ for (String memberName : expedition.getMembers().values()) {
log += ">>" + memberName + "\r\n"; log += ">>" + memberName + "\r\n";
} }
log += "BOSS KILLS\r\n"; log += "BOSS KILLS\r\n";
for (String message: expedition.getBossLogs()){ for (String message : expedition.getBossLogs()) {
log += message; log += message;
} }
log += "\r\n"; log += "\r\n";
FilePrinter.print(FilePrinter.LOG_EXPEDITION, log); FilePrinter.print(FilePrinter.LOG_EXPEDITION, log);
} }
public static String getTimeString(long then){
long duration = System.currentTimeMillis() - then;
int seconds = (int) (duration / 1000) % 60 ;
int minutes = (int) ((duration / (1000*60)) % 60);
return minutes + " Minutes and " + seconds + " Seconds";
}
public static void logLeaf(Character player, boolean gotPrize, String operation) { public static String getTimeString(long then) {
String timeStamp = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss").format(new Date()); long duration = System.currentTimeMillis() - then;
String log = player.getName() + (gotPrize ? " used a maple leaf to buy " + operation : " redeemed " + operation + " VP for a leaf") + " - " + timeStamp; int seconds = (int) (duration / 1000) % 60;
FilePrinter.print(FilePrinter.LOG_LEAF, log); int minutes = (int) ((duration / (1000 * 60)) % 60);
} return minutes + " Minutes and " + seconds + " Seconds";
}
public static void logGacha(Character player, int itemid, String map) {
String itemName = ItemInformationProvider.getInstance().getName(itemid);
String timeStamp = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss").format(new Date());
String log = player.getName() + " got a " + itemName + "(" + itemid + ") from the " + map + " gachapon. - " + timeStamp;
FilePrinter.print(FilePrinter.LOG_GACHAPON, log);
}
public static void logChat(Client player, String chatType, String text){ public static void logLeaf(Character player, boolean gotPrize, String operation) {
SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy HH:mm"); String timeStamp = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss").format(new Date());
FilePrinter.print(FilePrinter.LOG_CHAT, "[" + sdf.format(Calendar.getInstance().getTime()) + "] (" + chatType + ") " +player.getPlayer().getName() + ": " + text); String log = player.getName() + (gotPrize ? " used a maple leaf to buy " + operation : " redeemed " + operation + " VP for a leaf") + " - " + timeStamp;
} FilePrinter.print(FilePrinter.LOG_LEAF, log);
}
public static void logGacha(Character player, int itemid, String map) {
String itemName = ItemInformationProvider.getInstance().getName(itemid);
String timeStamp = new SimpleDateFormat("dd-MM-yyyy hh:mm:ss").format(new Date());
String log = player.getName() + " got a " + itemName + "(" + itemid + ") from the " + map + " gachapon. - " + timeStamp;
FilePrinter.print(FilePrinter.LOG_GACHAPON, log);
}
public static void logChat(Client player, String chatType, String text) {
SimpleDateFormat sdf = new SimpleDateFormat("dd-MM-yyyy HH:mm");
FilePrinter.print(FilePrinter.LOG_CHAT, "[" + sdf.format(Calendar.getInstance().getTime()) + "] (" + chatType + ") " + player.getPlayer().getName() + ": " + text);
}
} }

18
src/main/java/tools/LongTool.java
View File

@@ -1,23 +1,19 @@
package tools; package tools;
/** /**
*
* @author Shavit * @author Shavit
*/ */
public class LongTool { public class LongTool {
// Converts 8 bytes to a long. // Converts 8 bytes to a long.
public static long BytesToLong(byte[] aToConvert) public static long BytesToLong(byte[] aToConvert) {
{ if (aToConvert.length != Long.BYTES) {
if(aToConvert.length != Long.BYTES)
{
throw new IllegalArgumentException(String.format("Size of input should be %d", (Long.SIZE / 8))); throw new IllegalArgumentException(String.format("Size of input should be %d", (Long.SIZE / 8)));
} }
long nResult = 0; long nResult = 0;
for(int i = 0; i < Long.BYTES; i++) for (int i = 0; i < Long.BYTES; i++) {
{
nResult <<= Byte.SIZE; nResult <<= Byte.SIZE;
nResult |= (aToConvert[i] & 0xFF); nResult |= (aToConvert[i] & 0xFF);
} }
@@ -26,12 +22,10 @@ public class LongTool {
} }
// Converts a long to 8 bytes. // Converts a long to 8 bytes.
public static byte[] LongToBytes(long nToConvert) public static byte[] LongToBytes(long nToConvert) {
{
byte[] aBytes = new byte[Long.BYTES]; byte[] aBytes = new byte[Long.BYTES];
for(int i = aBytes.length - 1; i >= 0; i--) for (int i = aBytes.length - 1; i >= 0; i--) {
{
aBytes[i] = (byte) (nToConvert & 0xFF); aBytes[i] = (byte) (nToConvert & 0xFF);
nToConvert >>= Byte.SIZE; nToConvert >>= Byte.SIZE;
} }

32
src/main/java/tools/PacketCreator.java
View File

@@ -1736,7 +1736,7 @@ public class PacketCreator {
/** /**
* Gets a packet telling the client that a monster was killed. * Gets a packet telling the client that a monster was killed.
* *
* @param objId The objectID of the killed monster. * @param objId The objectID of the killed monster.
* @param animation 0 = dissapear, 1 = fade out, 2+ = special * @param animation 0 = dissapear, 1 = fade out, 2+ = special
* @return The kill monster packet. * @return The kill monster packet.
*/ */
@@ -2130,9 +2130,9 @@ public class PacketCreator {
/** /**
* Adds an announcement box to an existing OutPacket. * Adds an announcement box to an existing OutPacket.
* *
* @param p The OutPacket to add an announcement box * @param p The OutPacket to add an announcement box
* to. * to.
* @param shop The shop to announce. * @param shop The shop to announce.
*/ */
private static void addAnnounceBox(final OutPacket p, PlayerShop shop, int availability) { private static void addAnnounceBox(final OutPacket p, PlayerShop shop, int availability) {
p.writeByte(4); p.writeByte(4);
@@ -5507,9 +5507,9 @@ public class PacketCreator {
public static Packet showNameChangeCancel(boolean success) { public static Packet showNameChangeCancel(boolean success) {
OutPacket p = OutPacket.create(SendOpcode.CANCEL_NAME_CHANGE_RESULT); OutPacket p = OutPacket.create(SendOpcode.CANCEL_NAME_CHANGE_RESULT);
p.writeBool(success); p.writeBool(success);
if (!success) { if (!success) {
p.writeByte(0); p.writeByte(0);
} }
//p.writeString("Custom message."); //only if ^ != 0 //p.writeString("Custom message."); //only if ^ != 0
return p; return p;
} }
@@ -5517,9 +5517,9 @@ public class PacketCreator {
public static Packet showWorldTransferCancel(boolean success) { public static Packet showWorldTransferCancel(boolean success) {
OutPacket p = OutPacket.create(SendOpcode.CANCEL_TRANSFER_WORLD_RESULT); OutPacket p = OutPacket.create(SendOpcode.CANCEL_TRANSFER_WORLD_RESULT);
p.writeBool(success); p.writeBool(success);
if (!success) { if (!success) {
p.writeByte(0); p.writeByte(0);
} }
//p.writeString("Custom message."); //only if ^ != 0 //p.writeString("Custom message."); //only if ^ != 0
return p; return p;
} }
@@ -5854,14 +5854,14 @@ public class PacketCreator {
} }
} }
for (FamilyEntry junior : entry.getJuniors()) { for (FamilyEntry junior : entry.getJuniors()) {
if (junior == null) { if (junior == null) {
continue; continue;
} }
entryCount++; entryCount++;
for (FamilyEntry superJunior : junior.getJuniors()) { for (FamilyEntry superJunior : junior.getJuniors()) {
if (superJunior == null) { if (superJunior == null) {
continue; continue;
} }
entryCount++; entryCount++;
superJuniors.add(superJunior); superJuniors.add(superJunior);
} }

20
src/main/java/tools/Pair.java
View File

@@ -22,13 +22,12 @@ package tools;
/** /**
* Represents a pair of values. * Represents a pair of values.
* *
* @author Frz
* @since Revision 333
* @version 1.0
*
* @param <E> The type of the left value. * @param <E> The type of the left value.
* @param <F> The type of the right value. * @param <F> The type of the right value.
* @author Frz
* @version 1.0
* @since Revision 333
*/ */
public class Pair<E, F> { public class Pair<E, F> {
@@ -38,7 +37,7 @@ public class Pair<E, F> {
/** /**
* Class constructor - pairs two objects together. * Class constructor - pairs two objects together.
* *
* @param left The left object. * @param left The left object.
* @param right The right object. * @param right The right object.
*/ */
public Pair(E left, F right) { public Pair(E left, F right) {
@@ -110,12 +109,7 @@ public class Pair<E, F> {
return false; return false;
} }
if (right == null) { if (right == null) {
if (other.right != null) { return other.right == null;
return false; } else return right.equals(other.right);
}
} else if (!right.equals(other.right)) {
return false;
}
return true;
} }
} }

16
src/main/java/tools/Randomizer.java
View File

@@ -7,34 +7,34 @@ public class Randomizer {
private final static Random rand = new Random(); private final static Random rand = new Random();
public static int nextInt() { public static int nextInt() {
return rand.nextInt(); return rand.nextInt();
} }
public static int nextInt(final int arg0) { public static int nextInt(final int arg0) {
return rand.nextInt(arg0); return rand.nextInt(arg0);
} }
public static void nextBytes(final byte[] bytes) { public static void nextBytes(final byte[] bytes) {
rand.nextBytes(bytes); rand.nextBytes(bytes);
} }
public static boolean nextBoolean() { public static boolean nextBoolean() {
return rand.nextBoolean(); return rand.nextBoolean();
} }
public static double nextDouble() { public static double nextDouble() {
return rand.nextDouble(); return rand.nextDouble();
} }
public static float nextFloat() { public static float nextFloat() {
return rand.nextFloat(); return rand.nextFloat();
} }
public static long nextLong() { public static long nextLong() {
return rand.nextLong(); return rand.nextLong();
} }
public static int rand(final int lbound, final int ubound) { public static int rand(final int lbound, final int ubound) {
return (int) ((rand.nextDouble() * (ubound - lbound + 1)) + lbound); return (int) ((rand.nextDouble() * (ubound - lbound + 1)) + lbound);
} }
} }

196
src/main/java/tools/StringUtil.java
View File

@@ -22,107 +22,107 @@
package tools; package tools;
public class StringUtil { public class StringUtil {
/** /**
* Gets a string padded from the left to <code>length</code> by * Gets a string padded from the left to <code>length</code> by
* <code>padchar</code>. * <code>padchar</code>.
* *
* @param in The input string to be padded. * @param in The input string to be padded.
* @param padchar The character to pad with. * @param padchar The character to pad with.
* @param length The length to pad to. * @param length The length to pad to.
* @return The padded string. * @return The padded string.
*/ */
public static String getLeftPaddedStr(String in, char padchar, int length) { public static String getLeftPaddedStr(String in, char padchar, int length) {
StringBuilder builder = new StringBuilder(length); StringBuilder builder = new StringBuilder(length);
for (int x = in.length(); x < length; x++) { for (int x = in.length(); x < length; x++) {
builder.append(padchar); builder.append(padchar);
} }
builder.append(in); builder.append(in);
return builder.toString(); return builder.toString();
} }
/** /**
* Gets a string padded from the right to <code>length</code> by * Gets a string padded from the right to <code>length</code> by
* <code>padchar</code>. * <code>padchar</code>.
* *
* @param in The input string to be padded. * @param in The input string to be padded.
* @param padchar The character to pad with. * @param padchar The character to pad with.
* @param length The length to pad to. * @param length The length to pad to.
* @return The padded string. * @return The padded string.
*/ */
public static String getRightPaddedStr(String in, char padchar, int length) { public static String getRightPaddedStr(String in, char padchar, int length) {
StringBuilder builder = new StringBuilder(in); StringBuilder builder = new StringBuilder(in);
for (int x = in.length(); x < length; x++) { for (int x = in.length(); x < length; x++) {
builder.append(padchar); builder.append(padchar);
} }
return builder.toString(); return builder.toString();
} }
/** /**
* Joins an array of strings starting from string <code>start</code> with * Joins an array of strings starting from string <code>start</code> with
* a space. * a space.
* *
* @param arr The array of strings to join. * @param arr The array of strings to join.
* @param start Starting from which string. * @param start Starting from which string.
* @return The joined strings. * @return The joined strings.
*/ */
public static String joinStringFrom(String[] arr, int start) { public static String joinStringFrom(String[] arr, int start) {
return joinStringFrom(arr, start, " "); return joinStringFrom(arr, start, " ");
} }
/** /**
* Joins an array of strings starting from string <code>start</code> with * Joins an array of strings starting from string <code>start</code> with
* <code>sep</code> as a seperator. * <code>sep</code> as a seperator.
* *
* @param arr The array of strings to join. * @param arr The array of strings to join.
* @param start Starting from which string. * @param start Starting from which string.
* @return The joined strings. * @return The joined strings.
*/ */
public static String joinStringFrom(String[] arr, int start, String sep) { public static String joinStringFrom(String[] arr, int start, String sep) {
StringBuilder builder = new StringBuilder(); StringBuilder builder = new StringBuilder();
for (int i = start; i < arr.length; i++) { for (int i = start; i < arr.length; i++) {
builder.append(arr[i]); builder.append(arr[i]);
if (i != arr.length - 1) { if (i != arr.length - 1) {
builder.append(sep); builder.append(sep);
} }
} }
return builder.toString(); return builder.toString();
} }
/** /**
* Makes an enum name human readable (fixes spaces, capitalization, etc) * Makes an enum name human readable (fixes spaces, capitalization, etc)
* *
* @param enumName The name of the enum to neaten up. * @param enumName The name of the enum to neaten up.
* @return The human-readable enum name. * @return The human-readable enum name.
*/ */
public static String makeEnumHumanReadable(String enumName) { public static String makeEnumHumanReadable(String enumName) {
StringBuilder builder = new StringBuilder(enumName.length() + 1); StringBuilder builder = new StringBuilder(enumName.length() + 1);
String[] words = enumName.split("_"); String[] words = enumName.split("_");
for (String word : words) { for (String word : words) {
if (word.length() <= 2) { if (word.length() <= 2) {
builder.append(word); // assume that it's an abbrevation builder.append(word); // assume that it's an abbrevation
} else { } else {
builder.append(word.charAt(0)); builder.append(word.charAt(0));
builder.append(word.substring(1).toLowerCase()); builder.append(word.substring(1).toLowerCase());
} }
builder.append(' '); builder.append(' ');
} }
return builder.substring(0, enumName.length()); return builder.substring(0, enumName.length());
} }
/** /**
* Counts the number of <code>chr</code>'s in <code>str</code>. * Counts the number of <code>chr</code>'s in <code>str</code>.
* *
* @param str The string to check for instances of <code>chr</code>. * @param str The string to check for instances of <code>chr</code>.
* @param chr The character to check for. * @param chr The character to check for.
* @return The number of times <code>chr</code> occurs in <code>str</code>. * @return The number of times <code>chr</code> occurs in <code>str</code>.
*/ */
public static int countCharacters(String str, char chr) { public static int countCharacters(String str, char chr) {
int ret = 0; int ret = 0;
for (int i = 0; i < str.length(); i++) { for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) == chr) { if (str.charAt(i) == chr) {
ret++; ret++;
} }
} }
return ret; return ret;
} }
} }

3
src/main/java/tools/exceptions/EmptyMovementException.java
View File

@@ -23,11 +23,10 @@ import net.packet.InPacket;
/** /**
*
* @author Ronan * @author Ronan
*/ */
public class EmptyMovementException extends Exception { public class EmptyMovementException extends Exception {
public EmptyMovementException(InPacket inPacket) { public EmptyMovementException(InPacket inPacket) {
super("Empty movement: " + inPacket); super("Empty movement: " + inPacket);
} }

5
src/main/java/tools/exceptions/EventInstanceInProgressException.java
View File

@@ -21,13 +21,12 @@ package tools.exceptions;
/** /**
*
* @author Ronan * @author Ronan
*/ */
public class EventInstanceInProgressException extends Exception { public class EventInstanceInProgressException extends Exception {
public static String EIIP_KEY = "Event instance "; public static String EIIP_KEY = "Event instance ";
public EventInstanceInProgressException(String eventName, String eventInstance) { public EventInstanceInProgressException(String eventName, String eventInstance) {
super(EIIP_KEY + "already in progress - " + eventName + ", EM: " + eventInstance); super(EIIP_KEY + "already in progress - " + eventName + ", EM: " + eventInstance);
} }

22
src/main/java/tools/mapletools/CashCosmeticsFetcher.java
View File

@@ -11,15 +11,13 @@ import java.nio.charset.StandardCharsets;
import java.util.*; import java.util.*;
/** /**
*
* @author RonanLana * @author RonanLana
* <p>
This application gathers info from the WZ.XML files, fetching all cosmetic coupons and tickets from there, and then * This application gathers info from the WZ.XML files, fetching all cosmetic coupons and tickets from there, and then
searches the NPC script files, identifying the stylish NPCs that supposedly uses them. It will reports all NPCs that * searches the NPC script files, identifying the stylish NPCs that supposedly uses them. It will reports all NPCs that
uses up a card, as well as report those currently unused. * uses up a card, as well as report those currently unused.
* <p>
Estimated parse time: 10 seconds * Estimated parse time: 10 seconds
*/ */
public class CashCosmeticsFetcher { public class CashCosmeticsFetcher {
private static final Map<Integer, String> scriptEntries = new HashMap<>(500); private static final Map<Integer, String> scriptEntries = new HashMap<>(500);
@@ -41,7 +39,7 @@ public class CashCosmeticsFetcher {
private static int getNpcIdFromFilename(String name) { private static int getNpcIdFromFilename(String name) {
try { try {
return Integer.parseInt(name.substring(0, name.indexOf('.'))); return Integer.parseInt(name.substring(0, name.indexOf('.')));
} catch(Exception e) { } catch (Exception e) {
return -1; return -1;
} }
} }
@@ -50,7 +48,7 @@ public class CashCosmeticsFetcher {
ArrayList<File> files = new ArrayList<>(); ArrayList<File> files = new ArrayList<>();
listFiles(ToolConstants.SCRIPTS_PATH + "/npc", files); listFiles(ToolConstants.SCRIPTS_PATH + "/npc", files);
for(File f : files) { for (File f : files) {
Integer npcid = getNpcIdFromFilename(f.getName()); Integer npcid = getNpcIdFromFilename(f.getName());
//System.out.println("Parsing " + f.getAbsolutePath()); //System.out.println("Parsing " + f.getAbsolutePath());
@@ -60,7 +58,7 @@ public class CashCosmeticsFetcher {
StringBuilder stringBuffer = new StringBuilder(); StringBuilder stringBuffer = new StringBuilder();
String line; String line;
while((line = bufferedReader.readLine())!=null){ while ((line = bufferedReader.readLine()) != null) {
stringBuffer.append(line).append("\n"); stringBuffer.append(line).append("\n");
} }
@@ -108,7 +106,7 @@ public class CashCosmeticsFetcher {
System.out.println("Loaded scripts"); System.out.println("Loaded scripts");
reportCosmeticCouponResults(); reportCosmeticCouponResults();
} catch(Exception e) { } catch (Exception e) {
e.printStackTrace(); e.printStackTrace();
} }
} }

39
src/main/java/tools/mapletools/CashVegaChecker.java
View File

@@ -8,13 +8,12 @@ import java.util.HashSet;
import java.util.Set; import java.util.Set;
/** /**
*
* @author RonanLana * @author RonanLana
* * <p>
This application main objective is to read Vega-related information from * This application main objective is to read Vega-related information from
the item's description report back missing nodes for these items. * the item's description report back missing nodes for these items.
* <p>
Estimated parse time: 10 seconds * Estimated parse time: 10 seconds
*/ */
public class CashVegaChecker { public class CashVegaChecker {
private static final File OUTPUT_FILE = ToolConstants.getOutputFile("vega_checker_report.txt"); private static final File OUTPUT_FILE = ToolConstants.getOutputFile("vega_checker_report.txt");
@@ -40,7 +39,7 @@ public class CashVegaChecker {
token.getChars(i, j, dest, 0); token.getChars(i, j, dest, 0);
d = new String(dest); d = new String(dest);
return(d.trim()); return (d.trim());
} }
private static String getValue(String token) { private static String getValue(String token) {
@@ -56,36 +55,33 @@ public class CashVegaChecker {
token.getChars(i, j, dest, 0); token.getChars(i, j, dest, 0);
d = new String(dest); d = new String(dest);
return(d.trim()); return (d.trim());
} }
private static void forwardCursor(int st) { private static void forwardCursor(int st) {
String line = null; String line = null;
try { try {
while(status >= st && (line = bufferedReader.readLine()) != null) { while (status >= st && (line = bufferedReader.readLine()) != null) {
simpleToken(line); simpleToken(line);
} }
} } catch (Exception e) {
catch(Exception e) {
e.printStackTrace(); e.printStackTrace();
} }
} }
private static void simpleToken(String token) { private static void simpleToken(String token) {
if(token.contains("/imgdir")) { if (token.contains("/imgdir")) {
status -= 1; status -= 1;
} } else if (token.contains("imgdir")) {
else if(token.contains("imgdir")) {
status += 1; status += 1;
} }
} }
private static void translateItemToken(String token) { private static void translateItemToken(String token) {
if(token.contains("/imgdir")) { if (token.contains("/imgdir")) {
status -= 1; status -= 1;
} } else if (token.contains("imgdir")) {
else if(token.contains("imgdir")) {
status += 1; status += 1;
if (status == 2) { if (status == 2) {
@@ -101,10 +97,9 @@ public class CashVegaChecker {
} }
private static void translateVegaToken(String token) { private static void translateVegaToken(String token) {
if(token.contains("/imgdir")) { if (token.contains("/imgdir")) {
status -= 1; status -= 1;
} } else if (token.contains("imgdir")) {
else if(token.contains("imgdir")) {
status += 1; status += 1;
} else { } else {
if (status == 2) { if (status == 2) {
@@ -122,7 +117,7 @@ public class CashVegaChecker {
bufferedReader = new BufferedReader(fileReader); bufferedReader = new BufferedReader(fileReader);
String line; String line;
while((line = bufferedReader.readLine())!=null){ while ((line = bufferedReader.readLine()) != null) {
translateItemToken(line); translateItemToken(line);
} }
@@ -141,7 +136,7 @@ public class CashVegaChecker {
bufferedReader = new BufferedReader(fileReader); bufferedReader = new BufferedReader(fileReader);
String line; String line;
while((line = bufferedReader.readLine())!=null){ while ((line = bufferedReader.readLine()) != null) {
translateVegaToken(line); translateVegaToken(line);
} }

7
src/main/java/tools/mapletools/MakerItemEntry.java
View File

@@ -22,7 +22,6 @@ package tools.mapletools;
import java.util.List; import java.util.List;
/** /**
*
* @author RonanLana * @author RonanLana
*/ */
public class MakerItemEntry { public class MakerItemEntry {
@@ -36,13 +35,13 @@ public class MakerItemEntry {
public int catalyst = -1; public int catalyst = -1;
public int quantity = -1; public int quantity = -1;
public int tuc = -1; public int tuc = -1;
public int recipeCount = -1; public int recipeCount = -1;
public int recipeItem = -1; public int recipeItem = -1;
public List<int[]> recipeList = null; public List<int[]> recipeList = null;
public List<int[]> randomList = null; public List<int[]> randomList = null;
MakerItemEntry(int id, int itemid, int reqLevel, int reqMakerLevel, int reqItem, int reqMeso, int reqEquip, int catalyst, int quantity, int tuc, int recipeCount, int recipeItem, List<int[]> recipeList, List<int[]> randomList) { MakerItemEntry(int id, int itemid, int reqLevel, int reqMakerLevel, int reqItem, int reqMeso, int reqEquip, int catalyst, int quantity, int tuc, int recipeCount, int recipeItem, List<int[]> recipeList, List<int[]> randomList) {
this.id = id; this.id = id;
this.itemid = itemid; this.itemid = itemid;

2
src/main/java/tools/mapletools/MonsterStatFetcher.java
View File

@@ -121,7 +121,7 @@ public class MonsterStatFetcher {
} }
monsterStats.put(mid, stats); monsterStats.put(mid, stats);
} catch(NullPointerException npe) { } catch (NullPointerException npe) {
//System.out.println("[SEVERE] " + mFile.getName() + " failed to load. Issue: " + npe.getMessage() + "\n\n"); //System.out.println("[SEVERE] " + mFile.getName() + " failed to load. Issue: " + npe.getMessage() + "\n\n");
} }
} }

107
src/main/java/tools/packets/Fishing.java
View File

@@ -28,170 +28,169 @@ import tools.PacketCreator;
import java.util.Calendar; import java.util.Calendar;
/** /**
*
* @author FateJiki (RaGeZONE) * @author FateJiki (RaGeZONE)
* @author Ronan - timing pattern * @author Ronan - timing pattern
*/ */
public class Fishing { public class Fishing {
private static double getFishingLikelihood(int x) { private static double getFishingLikelihood(int x) {
return 50.0 + 7.0 * (7.0 * Math.sin(x)) * (Math.cos(Math.pow(x, 0.777))); return 50.0 + 7.0 * (7.0 * Math.sin(x)) * (Math.cos(Math.pow(x, 0.777)));
} }
public static double[] fetchFishingLikelihood() { public static double[] fetchFishingLikelihood() {
Calendar calendar = Calendar.getInstance(); Calendar calendar = Calendar.getInstance();
int dayOfYear = calendar.get(Calendar.DAY_OF_YEAR); int dayOfYear = calendar.get(Calendar.DAY_OF_YEAR);
int hours = calendar.get(Calendar.HOUR); int hours = calendar.get(Calendar.HOUR);
int minutes = calendar.get(Calendar.MINUTE); int minutes = calendar.get(Calendar.MINUTE);
int seconds = calendar.get(Calendar.SECOND); int seconds = calendar.get(Calendar.SECOND);
double yearLikelihood = getFishingLikelihood(dayOfYear); double yearLikelihood = getFishingLikelihood(dayOfYear);
double timeLikelihood = getFishingLikelihood(hours + minutes + seconds); double timeLikelihood = getFishingLikelihood(hours + minutes + seconds);
return new double[]{yearLikelihood, timeLikelihood}; return new double[]{yearLikelihood, timeLikelihood};
} }
private static boolean hitFishingTime(Character chr, int baitLevel, double yearLikelihood, double timeLikelihood) { private static boolean hitFishingTime(Character chr, int baitLevel, double yearLikelihood, double timeLikelihood) {
double baitLikelihood = 0.0002 * chr.getWorldServer().getFishingRate() * baitLevel; // can improve 10.0 at "max level 50000" on rate 1x double baitLikelihood = 0.0002 * chr.getWorldServer().getFishingRate() * baitLevel; // can improve 10.0 at "max level 50000" on rate 1x
if (YamlConfig.config.server.USE_DEBUG) { if (YamlConfig.config.server.USE_DEBUG) {
chr.dropMessage(5, "----- FISHING RESULT -----"); chr.dropMessage(5, "----- FISHING RESULT -----");
chr.dropMessage(5, "Likelihoods - Year: " + yearLikelihood + " Time: " + timeLikelihood + " Meso: " + baitLikelihood); chr.dropMessage(5, "Likelihoods - Year: " + yearLikelihood + " Time: " + timeLikelihood + " Meso: " + baitLikelihood);
chr.dropMessage(5, "Score rolls - Year: " + (0.23 * yearLikelihood) + " Time: " + (0.77 * timeLikelihood) + " Meso: " + baitLikelihood); chr.dropMessage(5, "Score rolls - Year: " + (0.23 * yearLikelihood) + " Time: " + (0.77 * timeLikelihood) + " Meso: " + baitLikelihood);
} }
return (0.23 * yearLikelihood) + (0.77 * timeLikelihood) + (baitLikelihood) > 57.777; return (0.23 * yearLikelihood) + (0.77 * timeLikelihood) + (baitLikelihood) > 57.777;
} }
public static void doFishing(Character chr, int baitLevel, double yearLikelihood, double timeLikelihood){ public static void doFishing(Character chr, int baitLevel, double yearLikelihood, double timeLikelihood) {
// thanks Fadi, Vcoc for suggesting a custom fishing system // thanks Fadi, Vcoc for suggesting a custom fishing system
if (!chr.isLoggedinWorld() || !chr.isAlive()) { if (!chr.isLoggedinWorld() || !chr.isAlive()) {
return; return;
} }
if (!GameConstants.isFishingArea(chr.getMapId())) { if (!GameConstants.isFishingArea(chr.getMapId())) {
chr.dropMessage("You are not in a fishing area!"); chr.dropMessage("You are not in a fishing area!");
return; return;
} }
if (chr.getLevel() < 30) { if (chr.getLevel() < 30) {
chr.dropMessage(5, "You must be above level 30 to fish!"); chr.dropMessage(5, "You must be above level 30 to fish!");
return; return;
} }
String fishingEffect; String fishingEffect;
if (!hitFishingTime(chr, baitLevel, yearLikelihood, timeLikelihood)) { if (!hitFishingTime(chr, baitLevel, yearLikelihood, timeLikelihood)) {
fishingEffect = "Effect/BasicEff.img/Catch/Fail"; fishingEffect = "Effect/BasicEff.img/Catch/Fail";
} else { } else {
String rewardStr = ""; String rewardStr = "";
fishingEffect = "Effect/BasicEff.img/Catch/Success"; fishingEffect = "Effect/BasicEff.img/Catch/Success";
int rand = (int)(3.0 * Math.random()); int rand = (int) (3.0 * Math.random());
switch(rand){ switch (rand) {
case 0: case 0:
int mesoAward = (int)(1400.0 * Math.random() + 1201) * chr.getMesoRate() + (15 * chr.getLevel() / 5); int mesoAward = (int) (1400.0 * Math.random() + 1201) * chr.getMesoRate() + (15 * chr.getLevel() / 5);
chr.gainMeso(mesoAward, true, true, true); chr.gainMeso(mesoAward, true, true, true);
rewardStr = mesoAward + " mesos."; rewardStr = mesoAward + " mesos.";
break; break;
case 1: case 1:
int expAward = (int)(645.0 * Math.random() + 620.0) * chr.getExpRate() + (15 * chr.getLevel() / 4); int expAward = (int) (645.0 * Math.random() + 620.0) * chr.getExpRate() + (15 * chr.getLevel() / 4);
chr.gainExp(expAward, true, true); chr.gainExp(expAward, true, true);
rewardStr = expAward + " EXP."; rewardStr = expAward + " EXP.";
break; break;
case 2: case 2:
int itemid = getRandomItem(); int itemid = getRandomItem();
rewardStr = "a(n) " + ItemInformationProvider.getInstance().getName(itemid) + "."; rewardStr = "a(n) " + ItemInformationProvider.getInstance().getName(itemid) + ".";
if (chr.canHold(itemid)) { if (chr.canHold(itemid)) {
chr.getAbstractPlayerInteraction().gainItem(itemid, true); chr.getAbstractPlayerInteraction().gainItem(itemid, true);
} else { } else {
chr.showHint("Couldn't catch a(n) #r" + ItemInformationProvider.getInstance().getName(itemid) + "#k due to #e#b" + ItemConstants.getInventoryType(itemid) + "#k#n inventory limit."); chr.showHint("Couldn't catch a(n) #r" + ItemInformationProvider.getInstance().getName(itemid) + "#k due to #e#b" + ItemConstants.getInventoryType(itemid) + "#k#n inventory limit.");
rewardStr += ".. but has goofed up due to full inventory."; rewardStr += ".. but has goofed up due to full inventory.";
} }
break; break;
} }
chr.getMap().dropMessage(6, chr.getName() + " found " + rewardStr); chr.getMap().dropMessage(6, chr.getName() + " found " + rewardStr);
} }
chr.sendPacket(PacketCreator.showInfo(fishingEffect)); chr.sendPacket(PacketCreator.showInfo(fishingEffect));
chr.getMap().broadcastMessage(chr, PacketCreator.showForeignInfo(chr.getId(), fishingEffect), false); chr.getMap().broadcastMessage(chr, PacketCreator.showForeignInfo(chr.getId(), fishingEffect), false);
} }
public static int getRandomItem(){ public static int getRandomItem() {
int rand = (int)(100.0 * Math.random()); int rand = (int) (100.0 * Math.random());
int[] commons = {1002851, 2002020, 2002020, 2000006, 2000018, 2002018, 2002024, 2002027, 2002027, 2000018, 2000018, 2000018, 2000018, 2002030, 2002018, 2000016}; // filler' up int[] commons = {1002851, 2002020, 2002020, 2000006, 2000018, 2002018, 2002024, 2002027, 2002027, 2000018, 2000018, 2000018, 2000018, 2002030, 2002018, 2000016}; // filler' up
int[] uncommons = {1000025, 1002662, 1002812, 1002850, 1002881, 1002880, 1012072, 4020009, 2043220, 2043022, 2040543, 2044420, 2040943, 2043713, 2044220, 2044120, 2040429, 2043220, 2040943}; // filler' uptoo int[] uncommons = {1000025, 1002662, 1002812, 1002850, 1002881, 1002880, 1012072, 4020009, 2043220, 2043022, 2040543, 2044420, 2040943, 2043713, 2044220, 2044120, 2040429, 2043220, 2040943}; // filler' uptoo
int[] rares = {1002859, 1002553, 1002762, 1002763, 1002764, 1002765, 1002766, 1002663, 1002788, 1002949, 2049100, 2340000, 2040822, 2040822, 2040822, 2040822}; // filler' uplast int[] rares = {1002859, 1002553, 1002762, 1002763, 1002764, 1002765, 1002766, 1002663, 1002788, 1002949, 2049100, 2340000, 2040822, 2040822, 2040822, 2040822}; // filler' uplast
if(rand >= 25){ if (rand >= 25) {
return commons[(int)(commons.length * Math.random())]; return commons[(int) (commons.length * Math.random())];
} else if(rand <= 7 && rand >= 4){ } else if (rand <= 7 && rand >= 4) {
return uncommons[(int)(uncommons.length * Math.random())]; return uncommons[(int) (uncommons.length * Math.random())];
} else { } else {
return rares[(int)(rares.length * Math.random())]; return rares[(int) (rares.length * Math.random())];
} }
} }
private static void debugFishingLikelihood() { private static void debugFishingLikelihood() {
long[] a = new long[365], b = new long[365]; long[] a = new long[365], b = new long[365];
long hits = 0, hits10 = 0, total = 0; long hits = 0, hits10 = 0, total = 0;
for (int i = 0; i < 365; i++) { for (int i = 0; i < 365; i++) {
double yearLikelihood = getFishingLikelihood(i); double yearLikelihood = getFishingLikelihood(i);
int dayHits = 0, dayHits10 = 0; int dayHits = 0, dayHits10 = 0;
for (int k = 0; k < 24; k++) { for (int k = 0; k < 24; k++) {
for (int l = 0; l < 60; l++) { for (int l = 0; l < 60; l++) {
for (int m = 0; m < 60; m++) { for (int m = 0; m < 60; m++) {
double timeLikelihood = getFishingLikelihood(k + l + m); double timeLikelihood = getFishingLikelihood(k + l + m);
if ((0.23 * yearLikelihood) + (0.77 * timeLikelihood) > 57.777) { if ((0.23 * yearLikelihood) + (0.77 * timeLikelihood) > 57.777) {
hits++; hits++;
dayHits++; dayHits++;
} }
if ((0.23 * yearLikelihood) + (0.77 * timeLikelihood) + 10.0 > 57.777) { if ((0.23 * yearLikelihood) + (0.77 * timeLikelihood) + 10.0 > 57.777) {
hits10++; hits10++;
dayHits10++; dayHits10++;
} }
total++; total++;
} }
} }
} }
a[i] = dayHits; a[i] = dayHits;
b[i] = dayHits10; b[i] = dayHits10;
} }
long maxhit = 0, minhit = Long.MAX_VALUE; long maxhit = 0, minhit = Long.MAX_VALUE;
for (int i = 0; i < 365; i++) { for (int i = 0; i < 365; i++) {
if (maxhit < a[i]) { if (maxhit < a[i]) {
maxhit = a[i]; maxhit = a[i];
} }
if (minhit > a[i]) { if (minhit > a[i]) {
minhit = a[i]; minhit = a[i];
} }
} }
long maxhit10 = 0, minhit10 = Long.MAX_VALUE; long maxhit10 = 0, minhit10 = Long.MAX_VALUE;
for (int i = 0; i < 365; i++) { for (int i = 0; i < 365; i++) {
if (maxhit10 < b[i]) { if (maxhit10 < b[i]) {
maxhit10 = b[i]; maxhit10 = b[i];
} }
if (minhit10 > b[i]) { if (minhit10 > b[i]) {
minhit10 = b[i]; minhit10 = b[i];
} }
} }
System.out.println("Diary min " + minhit + " max " + maxhit); System.out.println("Diary min " + minhit + " max " + maxhit);
System.out.println("Diary10 min " + minhit10 + " max " + maxhit10); System.out.println("Diary10 min " + minhit10 + " max " + maxhit10);
System.out.println("Hits: " + hits + "Hits10: " + hits10 + " Total: " + total + " -- %1000: " + (hits * 1000 / total) + ", +10 %1000: " + (hits10 * 1000 / total)); System.out.println("Hits: " + hits + "Hits10: " + hits10 + " Total: " + total + " -- %1000: " + (hits * 1000 / total) + ", +10 %1000: " + (hits10 * 1000 / total));

163
src/main/java/tools/packets/WeddingPackets.java
View File

@@ -19,9 +19,9 @@ import java.util.List;
/** /**
* CField_Wedding, CField_WeddingPhoto, CWeddingMan, OnMarriageResult, and all Wedding/Marriage enum/structs. * CField_Wedding, CField_WeddingPhoto, CWeddingMan, OnMarriageResult, and all Wedding/Marriage enum/structs.
* *
* @author Eric * @author Eric
* * <p>
* Wishlists edited by Drago (Dragohe4rt) * Wishlists edited by Drago (Dragohe4rt)
*/ */
public class WeddingPackets extends PacketCreator { public class WeddingPackets extends PacketCreator {
@@ -48,24 +48,24 @@ public class WeddingPackets extends PacketCreator {
00000100 m_bStartWeddingCeremony dd ? 00000100 m_bStartWeddingCeremony dd ?
00000104 CWeddingMan ends 00000104 CWeddingMan ends
*/ */
public class Field_Wedding { public class Field_Wedding {
public int m_nNoticeCount; public int m_nNoticeCount;
public int m_nCurrentStep; public int m_nCurrentStep;
public int m_nBlessStartTime; public int m_nBlessStartTime;
} }
public class Field_WeddingPhoto { public class Field_WeddingPhoto {
public boolean m_bPictureTook; public boolean m_bPictureTook;
} }
public class GW_WeddingReservation { public class GW_WeddingReservation {
public int dwReservationNo; public int dwReservationNo;
public int dwGroom, dwBride; public int dwGroom, dwBride;
public String sGroomName, sBrideName; public String sGroomName, sBrideName;
public int usWeddingType; public int usWeddingType;
} }
public class WeddingWishList { public class WeddingWishList {
public Character pUser; public Character pUser;
public int dwMarriageNo; public int dwMarriageNo;
@@ -76,29 +76,30 @@ public class WeddingPackets extends PacketCreator {
public int usModifiedFlag; // dword public int usModifiedFlag; // dword
public boolean bLoaded; public boolean bLoaded;
} }
public class GW_WeddingWishList { public class GW_WeddingWishList {
public final int WEDDINGWL_MAX = 0xA; // enum WEDDINGWL public final int WEDDINGWL_MAX = 0xA; // enum WEDDINGWL
public int dwReservationNo; public int dwReservationNo;
public byte nGender; public byte nGender;
public String sItemName; public String sItemName;
} }
public enum MarriageStatus { public enum MarriageStatus {
SINGLE(0x0), SINGLE(0x0),
ENGAGED(0x1), ENGAGED(0x1),
RESERVED(0x2), RESERVED(0x2),
MARRIED(0x3); MARRIED(0x3);
private int ms; private final int ms;
private MarriageStatus(int ms) {
MarriageStatus(int ms) {
this.ms = ms; this.ms = ms;
} }
public int getMarriageStatus() { public int getMarriageStatus() {
return ms; return ms;
} }
} }
public enum MarriageRequest { public enum MarriageRequest {
AddMarriageRecord(0x0), AddMarriageRecord(0x0),
SetMarriageRecord(0x1), SetMarriageRecord(0x1),
@@ -107,16 +108,17 @@ public class WeddingPackets extends PacketCreator {
AddReservation(0x4), AddReservation(0x4),
DeleteReservation(0x5), DeleteReservation(0x5),
GetReservation(0x6); GetReservation(0x6);
private int req; private final int req;
private MarriageRequest(int req) {
MarriageRequest(int req) {
this.req = req; this.req = req;
} }
public int getMarriageRequest() { public int getMarriageRequest() {
return req; return req;
} }
} }
public enum WeddingType { public enum WeddingType {
CATHEDRAL(0x1), CATHEDRAL(0x1),
VEGAS(0x2), VEGAS(0x2),
@@ -124,32 +126,34 @@ public class WeddingPackets extends PacketCreator {
CATHEDRAL_NORMAL(0xB), CATHEDRAL_NORMAL(0xB),
VEGAS_PREMIUM(0x14), VEGAS_PREMIUM(0x14),
VEGAS_NORMAL(0x15); VEGAS_NORMAL(0x15);
private int wt; private final int wt;
private WeddingType(int wt) {
WeddingType(int wt) {
this.wt = wt; this.wt = wt;
} }
public int getType() { public int getType() {
return wt; return wt;
} }
} }
public enum WeddingMap { public enum WeddingMap {
WEDDINGTOWN(680000000), WEDDINGTOWN(680000000),
CHAPEL_STARTMAP(680000110), CHAPEL_STARTMAP(680000110),
CATHEDRAL_STARTMAP(680000210), CATHEDRAL_STARTMAP(680000210),
PHOTOMAP(680000300), PHOTOMAP(680000300),
EXITMAP(680000500); EXITMAP(680000500);
private int wm; private final int wm;
private WeddingMap(int wm) {
WeddingMap(int wm) {
this.wm = wm; this.wm = wm;
} }
public int getMap() { public int getMap() {
return wm; return wm;
} }
} }
public enum WeddingItem { public enum WeddingItem {
WR_MOONSTONE(1112803), // Wedding Ring WR_MOONSTONE(1112803), // Wedding Ring
WR_STARGEM(1112806), WR_STARGEM(1112806),
@@ -182,22 +186,23 @@ public class WeddingPackets extends PacketCreator {
WT_VEGAS_NORMAL(5251001), WT_VEGAS_NORMAL(5251001),
WT_VEGAS_PREMIUM(5251002), WT_VEGAS_PREMIUM(5251002),
WT_CATHEDRAL_PREMIUM(5251003); WT_CATHEDRAL_PREMIUM(5251003);
private int wi; private final int wi;
private WeddingItem(int wi) {
WeddingItem(int wi) {
this.wi = wi; this.wi = wi;
} }
public int getItem() { public int getItem() {
return wi; return wi;
} }
} }
/** /**
* <name> has requested engagement. Will you accept this proposal? * <name> has requested engagement. Will you accept this proposal?
* *
* @param name * @param name
* @param playerid * @param playerid
* @return mplew * @return mplew
*/ */
public static Packet onMarriageRequest(String name, int playerid) { public static Packet onMarriageRequest(String name, int playerid) {
OutPacket p = OutPacket.create(SendOpcode.MARRIAGE_REQUEST); OutPacket p = OutPacket.create(SendOpcode.MARRIAGE_REQUEST);
@@ -206,7 +211,7 @@ public class WeddingPackets extends PacketCreator {
p.writeInt(playerid); // playerid p.writeInt(playerid); // playerid
return p; return p;
} }
/** /**
* A quick rundown of how (I think based off of enough BMS searching) WeddingPhoto_OnTakePhoto works: * A quick rundown of how (I think based off of enough BMS searching) WeddingPhoto_OnTakePhoto works:
* - We send this packet with (first) the Groom / Bride IGNs * - We send this packet with (first) the Groom / Bride IGNs
@@ -217,15 +222,15 @@ public class WeddingPackets extends PacketCreator {
* - Finally, after encoding all of our data, we send this packet out to a MapGen application server * - Finally, after encoding all of our data, we send this packet out to a MapGen application server
* - The MapGen server will then retrieve the packet byte array and convert the bytes into a ImageIO 2D JPG output * - The MapGen server will then retrieve the packet byte array and convert the bytes into a ImageIO 2D JPG output
* - The result after converting into a JPG will then be remotely uploaded to /weddings/ with ReservedGroomName_ReservedBrideName to be displayed on the web server. * - The result after converting into a JPG will then be remotely uploaded to /weddings/ with ReservedGroomName_ReservedBrideName to be displayed on the web server.
* * <p>
* - Will no longer continue Wedding Photos, needs a WvsMapGen :( * - Will no longer continue Wedding Photos, needs a WvsMapGen :(
* *
* @param ReservedGroomName The groom IGN of the wedding * @param ReservedGroomName The groom IGN of the wedding
* @param ReservedBrideName The bride IGN of the wedding * @param ReservedBrideName The bride IGN of the wedding
* @param m_dwField The current field id (the id of the cake map, ex. 680000300) * @param m_dwField The current field id (the id of the cake map, ex. 680000300)
* @param m_uCount The current user count (equal to m_dwUsers.size) * @param m_uCount The current user count (equal to m_dwUsers.size)
* @param m_dwUsers The List of all Character guests within the current cake map to be encoded * @param m_dwUsers The List of all Character guests within the current cake map to be encoded
* @return mplew (MaplePacket) Byte array to be converted and read for byte[]->ImageIO * @return mplew (MaplePacket) Byte array to be converted and read for byte[]->ImageIO
*/ */
public static Packet onTakePhoto(String ReservedGroomName, String ReservedBrideName, int m_dwField, List<Character> m_dwUsers) { // OnIFailedAtWeddingPhotos public static Packet onTakePhoto(String ReservedGroomName, String ReservedBrideName, int m_dwField, List<Character> m_dwUsers) { // OnIFailedAtWeddingPhotos
OutPacket p = OutPacket.create(SendOpcode.WEDDING_PHOTO);// v53 header, convert -> v83 OutPacket p = OutPacket.create(SendOpcode.WEDDING_PHOTO);// v53 header, convert -> v83
@@ -233,7 +238,7 @@ public class WeddingPackets extends PacketCreator {
p.writeString(ReservedBrideName); p.writeString(ReservedBrideName);
p.writeInt(m_dwField); // field id? p.writeInt(m_dwField); // field id?
p.writeInt(m_dwUsers.size()); p.writeInt(m_dwUsers.size());
for (Character guest : m_dwUsers) { for (Character guest : m_dwUsers) {
// Begin Avatar Encoding // Begin Avatar Encoding
addCharLook(p, guest, false); // CUser::EncodeAvatar addCharLook(p, guest, false); // CUser::EncodeAvatar
@@ -256,17 +261,17 @@ public class WeddingPackets extends PacketCreator {
p.writeShort(guest.getPosition().y); // m_ptCurPos.y p.writeShort(guest.getPosition().y); // m_ptCurPos.y
p.writeByte(guest.getStance()); // guest.m_bMoveAction p.writeByte(guest.getStance()); // guest.m_bMoveAction
} }
return p; return p;
} }
/** /**
* Enable spouse chat and their engagement ring without @relog * Enable spouse chat and their engagement ring without @relog
* *
* @param marriageId * @param marriageId
* @param chr * @param chr
* @param wedding * @param wedding
* @return mplew * @return mplew
*/ */
public static Packet OnMarriageResult(int marriageId, Character chr, boolean wedding) { public static Packet OnMarriageResult(int marriageId, Character chr, boolean wedding) {
OutPacket p = OutPacket.create(SendOpcode.MARRIAGE_RESULT); OutPacket p = OutPacket.create(SendOpcode.MARRIAGE_RESULT);
@@ -284,15 +289,15 @@ public class WeddingPackets extends PacketCreator {
} }
p.writeFixedString(StringUtil.getRightPaddedStr(chr.getGender() == 0 ? chr.getName() : Character.getNameById(chr.getPartnerId()), '\0', 13)); p.writeFixedString(StringUtil.getRightPaddedStr(chr.getGender() == 0 ? chr.getName() : Character.getNameById(chr.getPartnerId()), '\0', 13));
p.writeFixedString(StringUtil.getRightPaddedStr(chr.getGender() == 0 ? Character.getNameById(chr.getPartnerId()) : chr.getName(), '\0', 13)); p.writeFixedString(StringUtil.getRightPaddedStr(chr.getGender() == 0 ? Character.getNameById(chr.getPartnerId()) : chr.getName(), '\0', 13));
return p; return p;
} }
/** /**
* To exit the Engagement Window (Waiting for her response...), we send a GMS-like pop-up. * To exit the Engagement Window (Waiting for her response...), we send a GMS-like pop-up.
* *
* @param msg * @param msg
* @return mplew * @return mplew
*/ */
public static Packet OnMarriageResult(final byte msg) { public static Packet OnMarriageResult(final byte msg) {
OutPacket p = OutPacket.create(SendOpcode.MARRIAGE_RESULT); OutPacket p = OutPacket.create(SendOpcode.MARRIAGE_RESULT);
@@ -303,13 +308,13 @@ public class WeddingPackets extends PacketCreator {
} }
return p; return p;
} }
/** /**
* The World Map includes 'loverPos' in which this packet controls * The World Map includes 'loverPos' in which this packet controls
* *
* @param partner * @param partner
* @param mapid * @param mapid
* @return mplew * @return mplew
*/ */
public static Packet OnNotifyWeddingPartnerTransfer(int partner, int mapid) { public static Packet OnNotifyWeddingPartnerTransfer(int partner, int mapid) {
OutPacket p = OutPacket.create(SendOpcode.NOTIFY_MARRIED_PARTNER_MAP_TRANSFER); OutPacket p = OutPacket.create(SendOpcode.NOTIFY_MARRIED_PARTNER_MAP_TRANSFER);
@@ -317,17 +322,17 @@ public class WeddingPackets extends PacketCreator {
p.writeInt(partner); p.writeInt(partner);
return p; return p;
} }
/** /**
* The wedding packet to display Pelvis Bebop and enable the Wedding Ceremony Effect between two characters * The wedding packet to display Pelvis Bebop and enable the Wedding Ceremony Effect between two characters
* CField_Wedding::OnWeddingProgress - Stages * CField_Wedding::OnWeddingProgress - Stages
* CField_Wedding::OnWeddingCeremonyEnd - Wedding Ceremony Effect * CField_Wedding::OnWeddingCeremonyEnd - Wedding Ceremony Effect
* *
* @param setBlessEffect * @param setBlessEffect
* @param groom * @param groom
* @param bride * @param bride
* @param step * @param step
* @return mplew * @return mplew
*/ */
public static Packet OnWeddingProgress(boolean setBlessEffect, int groom, int bride, byte step) { public static Packet OnWeddingProgress(boolean setBlessEffect, int groom, int bride, byte step) {
OutPacket p = OutPacket.create(setBlessEffect ? SendOpcode.WEDDING_CEREMONY_END : SendOpcode.WEDDING_PROGRESS); OutPacket p = OutPacket.create(setBlessEffect ? SendOpcode.WEDDING_CEREMONY_END : SendOpcode.WEDDING_PROGRESS);
@@ -338,13 +343,13 @@ public class WeddingPackets extends PacketCreator {
p.writeInt(bride); p.writeInt(bride);
return p; return p;
} }
/** /**
* When we open a Wedding Invitation, we display the Bride & Groom * When we open a Wedding Invitation, we display the Bride & Groom
* *
* @param groom * @param groom
* @param bride * @param bride
* @return mplew * @return mplew
*/ */
public static Packet sendWeddingInvitation(String groom, String bride) { public static Packet sendWeddingInvitation(String groom, String bride) {
OutPacket p = OutPacket.create(SendOpcode.MARRIAGE_RESULT); OutPacket p = OutPacket.create(SendOpcode.MARRIAGE_RESULT);
@@ -354,7 +359,7 @@ public class WeddingPackets extends PacketCreator {
p.writeShort(1); // 0 = Cathedral Normal?, 1 = Cathedral Premium?, 2 = Chapel Normal? p.writeShort(1); // 0 = Cathedral Normal?, 1 = Cathedral Premium?, 2 = Chapel Normal?
return p; return p;
} }
public static Packet sendWishList() { // fuck my life public static Packet sendWishList() { // fuck my life
OutPacket p = OutPacket.create(SendOpcode.MARRIAGE_REQUEST); OutPacket p = OutPacket.create(SendOpcode.MARRIAGE_REQUEST);
p.writeByte(9); p.writeByte(9);
@@ -362,12 +367,12 @@ public class WeddingPackets extends PacketCreator {
} }
/** /**
* Handles all of WeddingWishlist packets * Handles all of WeddingWishlist packets
* *
* @param mode * @param mode
* @param itemnames * @param itemnames
* @param items * @param items
* @return mplew * @return mplew
*/ */
public static Packet onWeddingGiftResult(byte mode, List<String> itemnames, List<Item> items) { public static Packet onWeddingGiftResult(byte mode, List<String> itemnames, List<Item> items) {
OutPacket p = OutPacket.create(SendOpcode.WEDDING_GIFT_RESULT); OutPacket p = OutPacket.create(SendOpcode.WEDDING_GIFT_RESULT);
@@ -376,7 +381,7 @@ public class WeddingPackets extends PacketCreator {
case 0xC: // 12 : You cannot give more than one present for each wishlist case 0xC: // 12 : You cannot give more than one present for each wishlist
case 0xE: // 14 : Failed to send the gift. case 0xE: // 14 : Failed to send the gift.
break; break;
case 0x09: { // Load Wedding Registry case 0x09: { // Load Wedding Registry
p.writeByte(itemnames.size()); p.writeByte(itemnames.size());
for (String names : itemnames) { for (String names : itemnames) {