889 | * @link http://aidanlister.com/2004/04/viewing-binary-data-as-a-hexdump-in-php/
890 | * @param string $data The string to be dumped
891 | * @param bool $htmloutput Set to false for non-HTML output
892 | * @param bool $uppercase Set to true for uppercase hex
893 | * @param bool $return Set to true to return the dump
894 | */
895 | function hexdump ($data, $htmloutput = true, $uppercase = false, $return = false)
896 | {
897 | // Init
898 | $hexi = '';
899 | $ascii = '';
900 | $dump = ($htmloutput === true) ? '' : '';
901 | $offset = 0;
902 | $len = strlen($data);
903 |
904 | // Upper or lower case hexadecimal
905 | $x = ($uppercase === false) ? 'x' : 'X';
906 |
907 | // Iterate string
908 | for ($i = $j = 0; $i < $len; $i++)
909 | {
910 | // Convert to hexidecimal
911 | $hexi .= sprintf("%02$x ", ord($data[$i]));
912 |
913 | // Replace non-viewable bytes with '.'
914 | if (ord($data[$i]) >= 32) {
915 | $ascii .= ($htmloutput === true) ?
916 | htmlentities($data[$i]) :
917 | $data[$i];
918 | } else {
919 | $ascii .= '.';
920 | }
921 |
922 | // Add extra column spacing
923 | if ($j === 7) {
924 | $hexi .= ' ';
925 | $ascii .= ' ';
926 | }
927 |
928 | // Add row
929 | if (++$j === 16 || $i === $len - 1) {
930 | // Join the hexi / ascii output
931 | $dump .= sprintf("%04$x %-49s %s", $offset, $hexi, $ascii);
932 |
933 | // Reset vars
934 | $hexi = $ascii = '';
935 | $offset += 16;
936 | $j = 0;
937 |
938 | // Add newline
939 | if ($i !== $len - 1) {
940 | $dump .= "\n";
941 | }
942 | }
943 | }
944 |
945 | // Finish dump
946 | $dump .= $htmloutput === true ?
947 | '' :
948 | '';
949 | $dump .= "\n";
950 |
951 | $dump = preg_replace("/[^[:print:]\\r\\n]/", ".", $dump);
952 |
953 | // Output method
954 | if ($return === false) {
955 | echo $dump;
956 | } else {
957 | return $dump;
958 | }
959 | }
960 |
961 | function utf16_decode( $str ) {
962 | if( strlen($str) < 2 ) return $str;
963 | $bom_be = true;
964 | $c0 = ord($str{0});
965 | $c1 = ord($str{1});
966 | if( $c0 == 0xfe && $c1 == 0xff ) { $str = substr($str,2); }
967 | elseif( $c0 == 0xff && $c1 == 0xfe ) { $str = substr($str,2); $bom_be = false; }
968 | $len = strlen($str);
969 | $newstr = '';
970 | for($i=0;$i<$len;$i+=2) {
971 | if( $bom_be ) { $val = ord($str{$i}) << 4; $val += ord($str{$i+1}); }
972 | else { $val = ord($str{$i+1}) << 4; $val += ord($str{$i}); }
973 | $newstr .= ($val == 0x228) ? "\n" : chr($val);
974 | }
975 | return $newstr;
976 | }
977 | ?>
978 |
--------------------------------------------------------------------------------
/materials.php:
--------------------------------------------------------------------------------
1 | "Air",
5 | 1 => "Stone",
6 | 2 => "Grass",
7 | 3 => "Dirt",
8 | 4 => "Cobblestone",
9 | 5 => "Plank",
10 | 6 => "Sapling",
11 | 7 => "Bedrock",
12 | 8 => "Water",
13 | 9 => "Water",
14 | 10 => "Lava",
15 | 11 => "Lava",
16 | 12 => "Sand",
17 | 13 => "Gravel",
18 | 14 => "Gold Ore",
19 | 15 => "Iron Ore",
20 | 16 => "Coal Ore",
21 | 17 => "Wood",
22 | 18 => "Leave",
23 | 19 => "Sponge",
24 | 20 => "Glass",
25 | 21 => "Lapis Lazuli Ore",
26 | 22 => "Lapis Lazuli Block",
27 | 23 => "Dispenser",
28 | 24 => "Sandstone",
29 | 25 => "Note Block",
30 |
31 | 35 => "Wool",
32 |
33 | 43 => "Double Slab",
34 | 44 => "Slab",
35 | 45 => "Brick",
36 | 46 => "TNT",
37 |
38 | 49 => "Obsidian",
39 |
40 | 53 => "Wood Stair",
41 | 54 => "Chest",
42 |
43 | 61 => "Furnace",
44 |
45 | 67 => "Cobblestone Stair",
46 |
47 | 79 => "Ice",
48 |
49 | 89 => "Glowstone",
50 |
51 | );
52 |
53 | $food = array(
54 | 282 => 8, //Stew
55 | 364 => 8, //Steak
56 | 320 => 8, //Porkchop
57 | 366 => 6, //Chicken
58 | 297 => 5, //Bread
59 | 350 => 5, //Fish
60 | 260 => 4, //R Apple
61 | 322 => 4, //G Apple
62 | 363 => 3, //Raw Beef
63 | 319 => 3, //Raw Porkchop
64 | 360 => 2, //Melon
65 | 349 => 2, //Raw fish
66 | 265 => 2, //Raw Chicken
67 | 357 => 1, //Cookie
68 | 367 => 4, //Flesh
69 | 375 => 2, //Spider eye,
70 | );
71 |
72 |
73 | ?>
--------------------------------------------------------------------------------
/nbt.class.php:
--------------------------------------------------------------------------------
1 |
6 | * @version 1.0
7 | *
8 | * Dependencies:
9 | * PHP 4.3+ (5.3+ recommended)
10 | * GMP Extension
11 | */
12 |
13 | extension_loaded("gmp") or trigger_error (
14 | "The NBT class requires the GMP extension for 64-bit number handling. ".
15 | "Excecution will continue, but will halt if a 64-bit number is handled.", E_USER_NOTICE
16 | );
17 |
18 | class NBT {
19 | public $root = array();
20 |
21 | public $verbose = false;
22 |
23 | const TAG_END = 0;
24 | const TAG_BYTE = 1;
25 | const TAG_SHORT = 2;
26 | const TAG_INT = 3;
27 | const TAG_LONG = 4;
28 | const TAG_FLOAT = 5;
29 | const TAG_DOUBLE = 6;
30 | const TAG_BYTE_ARRAY = 7;
31 | const TAG_STRING = 8;
32 | const TAG_LIST = 9;
33 | const TAG_COMPOUND = 10;
34 |
35 | public function loadFile($filename, $wrapper = "compress.zlib://") {
36 | if(is_string($wrapper) && is_file($filename)) {
37 | if($this->verbose) trigger_error("Loading file \"{$filename}\" with stream wrapper \"{$wrapper}\".", E_USER_NOTICE);
38 | $fp = fopen("{$wrapper}{$filename}", "rb");
39 | } elseif(is_null($wrapper) && is_resource($filename)) {
40 | if($this->verbose) trigger_error("Loading file from existing resource.", E_USER_NOTICE);
41 | $fp = $filename;
42 | } else {
43 | trigger_error("First parameter must be a filename or a resource.", E_USER_WARNING);
44 | return false;
45 | }
46 | if($this->verbose) trigger_error("Traversing first tag in file.", E_USER_NOTICE);
47 | $this->traverseTag($fp, $this->root);
48 | if($this->verbose) trigger_error("Encountered end tag for first tag; finished.", E_USER_NOTICE);
49 | return end($this->root);
50 | }
51 |
52 | public function writeFile($filename, $wrapper = "compress.zlib://") {
53 | if(is_string($wrapper)) {
54 | if($this->verbose) trigger_error("Writing file \"{$filename}\" with stream wrapper \"{$wrapper}\".", E_USER_NOTICE);
55 | $fp = fopen("{$wrapper}{$filename}", "wb");
56 | } elseif(is_null($wrapper) && is_resource($fp)) {
57 | if($this->verbose) trigger_error("Writing file to existing resource.", E_USER_NOTICE);
58 | $fp = $filename;
59 | } else {
60 | trigger_error("First parameter must be a filename or a resource.", E_USER_WARNING);
61 | return false;
62 | }
63 | if($this->verbose) trigger_error("Writing ".count($this->root)." root tag(s) to file/resource.", E_USER_NOTICE);
64 | foreach($this->root as $rootNum => $rootTag) if(!$this->writeTag($fp, $rootTag)) trigger_error("Failed to write root tag #{$rootNum} to file/resource.", E_USER_WARNING);
65 | return true;
66 | }
67 |
68 | public function purge() {
69 | if($this->verbose) trigger_error("Purging all loaded data", E_USER_ERROR);
70 | $this->root = array();
71 | }
72 |
73 | public function traverseTag($fp, &$tree) {
74 | if(feof($fp)) {
75 | if($this->verbose) trigger_error("Reached end of file/resource.", E_USER_NOTICE);
76 | return false;
77 | }
78 | $tagType = $this->readType($fp, self::TAG_BYTE); // Read type byte.
79 | if($tagType == self::TAG_END) {
80 | return false;
81 | } else {
82 | if($this->verbose) $position = ftell($fp);
83 | $tagName = $this->readType($fp, self::TAG_STRING);
84 | if($this->verbose) trigger_error("Reading tag \"{$tagName}\" at offset {$position}.", E_USER_NOTICE);
85 | $tagData = $this->readType($fp, $tagType);
86 | $tree[] = array("type"=>$tagType, "name"=>$tagName, "value"=>$tagData);
87 | return true;
88 | }
89 | }
90 |
91 | public function writeTag($fp, $tag) {
92 | if($this->verbose) {
93 | $position = ftell($fp);
94 | trigger_error("Writing tag \"{$tag["name"]}\" of type {$tag["type"]} at offset {$position}.", E_USER_NOTICE);
95 | }
96 | return $this->writeType($fp, self::TAG_BYTE, $tag["type"]) && $this->writeType($fp, self::TAG_STRING, $tag["name"]) && $this->writeType($fp, $tag["type"], $tag["value"]);
97 | }
98 |
99 | public function readType($fp, $tagType) {
100 | switch($tagType) {
101 | case self::TAG_BYTE: // Signed byte (8 bit)
102 | list(,$unpacked) = unpack("c", fread($fp, 1));
103 | return $unpacked;
104 | case self::TAG_SHORT: // Signed short (16 bit, big endian)
105 | list(,$unpacked) = unpack("n", fread($fp, 2));
106 | if($unpacked >= pow(2, 15)) $unpacked -= pow(2, 16); // Convert unsigned short to signed short.
107 | return $unpacked;
108 | case self::TAG_INT: // Signed integer (32 bit, big endian)
109 | list(,$unpacked) = unpack("N", fread($fp, 4));
110 | if($unpacked >= pow(2, 31)) $unpacked -= pow(2, 32); // Convert unsigned int to signed int
111 | return $unpacked;
112 | case self::TAG_LONG: // Signed long (64 bit, big endian)
113 | extension_loaded("gmp") or trigger_error (
114 | "This file contains a 64-bit number and execution cannot continue. ".
115 | "Please install the GMP extension for 64-bit number handling.", E_USER_ERROR
116 | );
117 | list(,$firstHalf) = unpack("N", fread($fp, 4));
118 | list(,$secondHalf) = unpack("N", fread($fp, 4));
119 | $value = gmp_add($secondHalf, gmp_mul($firstHalf, "4294967296"));
120 | if(gmp_cmp($value, gmp_pow(2, 63)) >= 0) $value = gmp_sub($value, gmp_pow(2, 64));
121 | return gmp_strval($value);
122 | case self::TAG_FLOAT: // Floating point value (32 bit, big endian, IEEE 754-2008)
123 | list(,$value) = (pack('d', 1) == "\77\360\0\0\0\0\0\0")?unpack('f', fread($fp, 4)):unpack('f', strrev(fread($fp, 4)));
124 | return $value;
125 | case self::TAG_DOUBLE: // Double value (64 bit, big endian, IEEE 754-2008)
126 | list(,$value) = (pack('d', 1) == "\77\360\0\0\0\0\0\0")?unpack('d', fread($fp, 8)):unpack('d', strrev(fread($fp, 8)));
127 | return $value;
128 | case self::TAG_BYTE_ARRAY: // Byte array
129 | $arrayLength = $this->readType($fp, self::TAG_INT);
130 | $array = array();
131 | for($i = 0; $i < $arrayLength; $i++) $array[] = $this->readType($fp, self::TAG_BYTE);
132 | return $array;
133 | case self::TAG_STRING: // String
134 | if(!$stringLength = $this->readType($fp, self::TAG_SHORT)) return "";
135 | $string = utf8_decode(fread($fp, $stringLength)); // Read in number of bytes specified by string length, and decode from utf8.
136 | return $string;
137 | case self::TAG_LIST: // List
138 | $tagID = $this->readType($fp, self::TAG_BYTE);
139 | $listLength = $this->readType($fp, self::TAG_INT);
140 | if($this->verbose) trigger_error("Reading in list of {$listLength} tags of type {$tagID}.", E_USER_NOTICE);
141 | $list = array("type"=>$tagID, "value"=>array());
142 | for($i = 0; $i < $listLength; $i++) {
143 | if(feof($fp)) break;
144 | $list["value"][] = $this->readType($fp, $tagID);
145 | }
146 | return $list;
147 | case self::TAG_COMPOUND: // Compound
148 | $tree = array();
149 | while($this->traverseTag($fp, $tree));
150 | return $tree;
151 | }
152 | }
153 |
154 | public function writeType($fp, $tagType, $value) {
155 | switch($tagType) {
156 | case self::TAG_BYTE: // Signed byte (8 bit)
157 | return is_int(fwrite($fp, pack("c", $value)));
158 | case self::TAG_SHORT: // Signed short (16 bit, big endian)
159 | if($value < 0) $value += pow(2, 16); // Convert signed short to unsigned short
160 | return is_int(fwrite($fp, pack("n", $value)));
161 | case self::TAG_INT: // Signed integer (32 bit, big endian)
162 | if($value < 0) $value += pow(2, 32); // Convert signed int to unsigned int
163 | return is_int(fwrite($fp, pack("N", $value)));
164 | case self::TAG_LONG: // Signed long (64 bit, big endian)
165 | extension_loaded("gmp") or trigger_error (
166 | "This file contains a 64-bit number and execution cannot continue. ".
167 | "Please install the GMP extension for 64-bit number handling.", E_USER_ERROR
168 | );
169 | $secondHalf = gmp_mod($value, 2147483647);
170 | $firstHalf = gmp_sub($value, $secondHalf);
171 | return is_int(fwrite($fp, pack("N", gmp_intval($firstHalf)))) && is_int(fwrite($fp, pack("N", gmp_intval($secondHalf))));
172 | case self::TAG_FLOAT: // Floating point value (32 bit, big endian, IEEE 754-2008)
173 | return is_int(fwrite($fp, (pack('d', 1) == "\77\360\0\0\0\0\0\0")?pack('f', $value):strrev(pack('f', $value))));
174 | case self::TAG_DOUBLE: // Double value (64 bit, big endian, IEEE 754-2008)
175 | return is_int(fwrite($fp, (pack('d', 1) == "\77\360\0\0\0\0\0\0")?pack('d', $value):strrev(pack('d', $value))));
176 | case self::TAG_BYTE_ARRAY: // Byte array
177 | return $this->writeType($fp, self::TAG_INT, count($value)) && is_int(fwrite($fp, call_user_func_array("pack", array_merge(array("c".count($value)), $value))));
178 | case self::TAG_STRING: // String
179 | $value = utf8_encode($value);
180 | return $this->writeType($fp, self::TAG_SHORT, strlen($value)) && is_int(fwrite($fp, $value));
181 | case self::TAG_LIST: // List
182 | if($this->verbose) trigger_error("Writing list of ".count($value["value"])." tags of type {$value["type"]}.", E_USER_NOTICE);
183 | if(!($this->writeType($fp, self::TAG_BYTE, $value["type"]) && $this->writeType($fp, self::TAG_INT, count($value["value"])))) return false;
184 | foreach($value["value"] as $listItem) if(!$this->writeType($fp, $value["type"], $listItem)) return false;
185 | return true;
186 | case self::TAG_COMPOUND: // Compound
187 | foreach($value as $listItem) if(!$this->writeTag($fp, $listItem)) return false;
188 | if(!is_int(fwrite($fp, "\0"))) return false;
189 | return true;
190 | }
191 | }
192 | }
193 | ?>
--------------------------------------------------------------------------------
/packets.php:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/packets/03Chat.php:
--------------------------------------------------------------------------------
1 | "), $packet["message"]);
13 | $channel = "";
14 | if(strpos($packet["message"], "]<") !== false){
15 | $packet["message"] = explode("]<", substr($packet["message"],1));
16 | $channel = $packet["message"][0];
17 | $packet["message"] = "<".$packet["message"][1];
18 | }
19 | $sender = false;
20 | $me = false;
21 | if($packet["message"]{0} == "["){
22 | $sender = explode(".", substr($packet["message"],1,strpos($packet["message"], "->")-2));
23 | $sender = isset($sender[1]) ? $sender[1]:$sender[0];
24 | $packet["message"] = substr($packet["message"],strpos($packet["message"], "]")+2);
25 | if(strpos($packet["message"],": ")!==false){
26 | $packet["message"] = explode("] ",$packet["message"]);
27 | $packet["message"] = trim($packet["message"][count($packet["message"])-1]);
28 | $sender = false;
29 | }
30 | }elseif(strpos($packet["message"], " whispers ") !== false){
31 | $sender = substr($packet["message"],0,strpos($packet["message"], " "));
32 | $packet["message"] = substr($packet["message"],strpos($packet["message"], " whispers ")+10);
33 | }
34 | if(stripos($packet["message"], "bot") !== false and $sender == false){
35 |
36 |
37 |
38 | if($packet["message"]{0} == "<"){
39 | $mess = substr($packet["message"],strpos($packet["message"], "> ")+2);
40 | $sender = explode(".", substr($packet["message"],1,strpos($packet["message"], "> ")-1));
41 | }else{
42 | $sender = explode(".", substr($packet["message"],0,strpos($packet["message"], ": ")));
43 | $mess = substr($packet["message"],strpos($packet["message"], ": ")+2);
44 | }
45 | $sender = isset($sender[1]) ? $sender[1]:$sender[0];
46 |
47 | if(strtolower(substr($mess,0,3)) != "bot"){
48 | $sender = false;
49 | }else{
50 | $me = true;
51 | $packet["message"] = substr($mess, ($mess{4} == " " ? 5:4));
52 | }
53 | }
54 |
55 | $mp = false;
56 | if(($sender !== false and $sender != "me" and $sender != "yo") or $me == true){
57 | $mp = true;
58 | $value = explode(" ", $packet["message"]);
59 | $command = strtolower($value[0]);
60 | unset($value[0]);
61 | $value = implode(" ",$value);
62 | if(!command($command, $value, $sender)){
63 | include("chat_help.php");
64 | }
65 | return "[$sender --> me] ".$packet["message"];
66 | }else{
67 | if($packet["message"]{0} == "<"){
68 | $sender = explode(".", substr($packet["message"],1,strpos($packet["message"], "> ")-1));
69 | }else{
70 | $sender = explode(".", substr($packet["message"],0,strpos($packet["message"], ": ")-1));
71 | }
72 | $sender = isset($sender[1]) ? $sender[1]:$sender[0];
73 | include("chat_help.php");
74 | return $packet["message"];
75 | }
76 | }
77 |
78 | function privateMessage($message, $target){
79 | foreach(explode("\n", wordwrap($message,100-strlen("/tell $target "), "\n")) as $mess){
80 | write_packet("03", array(
81 | "message" => "/tell $target $mess",
82 | ));
83 | }
84 | console("[me --> $target] ".$message);
85 | }
86 |
87 | function Message($message){
88 | foreach(explode("\n", wordwrap($message,100, "\n")) as $mess){
89 | write_packet("03", array(
90 | "message" => $mess,
91 | ));
92 | }
93 | }
94 | ?>
--------------------------------------------------------------------------------
/pstruct.php:
--------------------------------------------------------------------------------
1 | array(
11 | "int",
12 | ),
13 |
14 | "01" => array(
15 | "int",
16 | "string",
17 | "string",
18 | "int",
19 | "int",
20 | "byte",
21 | "ubyte",
22 | "ubyte",
23 | ),
24 |
25 | "02" => array(
26 | "string",
27 | ),
28 |
29 | "03" => array(
30 | "string",
31 | ),
32 |
33 | "04" => array(
34 | "long",
35 | ),
36 |
37 | "05" => array(
38 | "int",
39 | "short",
40 | "short",
41 | "short",
42 | ),
43 |
44 | "06" => array(
45 | "int",
46 | "int",
47 | "int",
48 | ),
49 |
50 | "08" => array(
51 | "short",
52 | "short",
53 | "float",
54 | ),
55 |
56 | "09" => array(
57 | "int",
58 | "byte",
59 | "byte",
60 | "short",
61 | "string",
62 | ),
63 |
64 | "0d" => array(
65 | "double",
66 | "double",
67 | "double",
68 | "double",
69 | "float",
70 | "float",
71 | "bool",
72 | ),
73 |
74 | "10" => array(
75 | "short",
76 | ),
77 |
78 | "11" => array(
79 | "int",
80 | "byte",
81 | "int",
82 | "byte",
83 | "int",
84 | ),
85 |
86 | "12" => array(
87 | "int",
88 | "byte",
89 | ),
90 |
91 | "14" => array(
92 | "int",
93 | "string",
94 | "int",
95 | "int",
96 | "int",
97 | "byte",
98 | "byte",
99 | "short",
100 | ),
101 |
102 | "15" => array(
103 | "int",
104 | "short",
105 | "byte",
106 | "short",
107 | "int",
108 | "int",
109 | "int",
110 | "byte",
111 | "byte",
112 | "byte",
113 | ),
114 |
115 | "16" => array(
116 | "int",
117 | "int",
118 | ),
119 |
120 | "17" => array(
121 | "int",
122 | "byte",
123 | "int",
124 | "int",
125 | "int",
126 | "int", //if >0, fireball
127 | "short",
128 | "short",
129 | "short",
130 | ),
131 |
132 | "18" => array(
133 | "int",
134 | "byte",
135 | "int",
136 | "int",
137 | "int",
138 | "byte",
139 | "byte",
140 | "byte",
141 | "entityMetadata",
142 | ),
143 |
144 | "19" => array(
145 | "int",
146 | "string",
147 | "int",
148 | "int",
149 | "int",
150 | "int",
151 | ),
152 |
153 | "1a" => array(
154 | "int",
155 | "int",
156 | "int",
157 | "int",
158 | "short",
159 | ),
160 |
161 | "1b" => array(
162 | "float",
163 | "float",
164 | "float",
165 | "float",
166 | "bool",
167 | "bool",
168 | ),
169 |
170 | "1c" => array(
171 | "int",
172 | "short",
173 | "short",
174 | "short",
175 | ),
176 |
177 | "1d" => array(
178 | "int",
179 | ),
180 |
181 | "1e" => array(
182 | "int",
183 | ),
184 |
185 | "1f" => array(
186 | "int",
187 | "byte",
188 | "byte",
189 | "byte",
190 | ),
191 |
192 | "20" => array(
193 | "int",
194 | "byte",
195 | "byte",
196 | ),
197 |
198 | "21" => array(
199 | "int",
200 | "byte",
201 | "byte",
202 | "byte",
203 | "byte",
204 | "byte",
205 | ),
206 |
207 | "22" => array(
208 | "int",
209 | "int",
210 | "int",
211 | "int",
212 | "byte",
213 | "byte",
214 | ),
215 |
216 | "23" => array(
217 | "int",
218 | "byte",
219 | ),
220 |
221 | "26" => array(
222 | "int",
223 | "byte",
224 | ),
225 |
226 | "27" => array(
227 | "int",
228 | "int",
229 | ),
230 |
231 | "28" => array(
232 | "int",
233 | "entityMetadata",
234 | ),
235 |
236 | "29" => array(
237 | "int",
238 | "byte",
239 | "byte",
240 | "short",
241 | ),
242 |
243 | "2a" => array(
244 | "int",
245 | "byte",
246 | ),
247 |
248 | "2b" => array(
249 | "float",
250 | "short",
251 | "short",
252 | ),
253 |
254 | "32" => array(
255 | "int",
256 | "int",
257 | "bool",
258 | ),
259 |
260 | "33" => array(
261 | "int",
262 | "int",
263 | "bool",
264 | "short",
265 | "short",
266 | "int",
267 | "int",
268 | "newChunkArray",
269 | ),
270 |
271 | "34" => array(
272 | "int",
273 | "int",
274 | "short",
275 | "int",
276 | "newMultiblockArray",
277 | ),
278 |
279 | "35" => array(
280 | "int",
281 | "byte",
282 | "int",
283 | "byte",
284 | "byte",
285 | ),
286 |
287 | "36" => array(
288 | "int",
289 | "short",
290 | "int",
291 | "byte",
292 | "byte",
293 | ),
294 |
295 | "3c" => array(
296 | "double",
297 | "double",
298 | "double",
299 | "float",
300 | "int",
301 | "explosionRecord"
302 | ),
303 |
304 | "3d" => array(
305 | "int",
306 | "int",
307 | "byte",
308 | "int",
309 | "int",
310 | ),
311 |
312 | "46" => array(
313 | "byte",
314 | "byte",
315 | ),
316 |
317 | "47" => array(
318 | "int",
319 | "bool",
320 | "int",
321 | "int",
322 | "int",
323 | ),
324 |
325 | "64" => array(
326 | "byte",
327 | "byte",
328 | "string",
329 | "byte",
330 | ),
331 |
332 | "65" => array(
333 | "byte",
334 | ),
335 |
336 | "67" => array(
337 | "byte",
338 | "short",
339 | "slotData",
340 | ),
341 |
342 | "68" => array(
343 | "byte",
344 | "short",
345 | "slotArray",
346 | ),
347 |
348 | "69" => array(
349 | "byte",
350 | "short",
351 | "short",
352 | ),
353 |
354 | "6a" => array(
355 | "byte",
356 | "short",
357 | "bool",
358 | ),
359 |
360 | "6b" => array(
361 | "short",
362 | "slotData",
363 | ),
364 |
365 | "6c" => array(
366 | "byte",
367 |
368 | ),
369 |
370 | "82" => array(
371 | "int",
372 | "short",
373 | "int",
374 | "string",
375 | "string",
376 | "string",
377 | "string",
378 | ),
379 |
380 | "83" => array(
381 | "short",
382 | "short",
383 | "ubyte",
384 | "byteArray",
385 | ),
386 |
387 | "84" => array(
388 | "int",
389 | "short",
390 | "int",
391 | "byte",
392 | "int",
393 | "int",
394 | "int",
395 | ),
396 |
397 | "c8" => array(
398 | "int",
399 | "byte",
400 | ),
401 |
402 | "c9" => array(
403 | "string",
404 | "byte",
405 | "short",
406 | ),
407 |
408 | "ca" => array(
409 | "bool",
410 | "bool",
411 | "bool",
412 | "bool",
413 | ),
414 |
415 | "cb" => array(
416 | "string",
417 | ),
418 |
419 | "fa" => array(
420 | "string",
421 | "short",
422 | "byteArray",
423 | ),
424 |
425 | "fe" => array(
426 | "string",
427 | ),
428 |
429 | "ff" => array(
430 | "string",
431 | ),
432 | );
433 |
434 |
435 | ?>
436 |
--------------------------------------------------------------------------------
/pstruct_modifier.php:
--------------------------------------------------------------------------------
1 | = 23){
7 | unset($pstruct["1b"]);
8 | }
9 |
10 | if($protocol <= 23){
11 | $pstruct["01"] = array(
12 | "int",
13 | "string",
14 | "long",
15 | "string",
16 | "int",
17 | "byte",
18 | "byte",
19 | "ubyte",
20 | "ubyte",
21 | );
22 | $pstruct["09"] = array(
23 | "byte",
24 | "byte",
25 | "byte",
26 | "short",
27 | "long",
28 | "string",
29 | );
30 | $pstruct["18"] = array(
31 | "int",
32 | "byte",
33 | "int",
34 | "int",
35 | "int",
36 | "byte",
37 | "byte",
38 | "entityMetadata",
39 | );
40 | $pstruct["33"] = array(
41 | "int",
42 | "short",
43 | "int",
44 | "byte",
45 | "byte",
46 | "byte",
47 | "int",
48 | "chunkArray",
49 | );
50 |
51 | $pstruct["34"] = array(
52 | "int",
53 | "int",
54 | "short",
55 | "multiblockArray",
56 | );
57 | }
58 |
59 | if($protocol <= 22){
60 | $pstruct["09"] = array(
61 | "byte",
62 | "byte",
63 | "byte",
64 | "short",
65 | "long",
66 | );
67 | $pstruct["01"] = array(
68 | "int",
69 | "string",
70 | "long",
71 | "int",
72 | "byte",
73 | "byte",
74 | "ubyte",
75 | "ubyte",
76 | );
77 | }
78 |
79 | if($protocol <= 17){
80 | $pstruct["2b"] = array(
81 | "byte",
82 | "byte",
83 | "short",
84 | );
85 | }
86 | if($protocol <= 14){
87 | $pstruct["00"] = array();
88 | $pstruct["01"] = array(
89 | "int",
90 | "string",
91 | "long",
92 | "byte",
93 | );
94 | $pstruct["46"] = array(
95 | "int",
96 | );
97 | }
98 |
99 | ?>
100 |
--------------------------------------------------------------------------------