diff --git a/.editorconfig b/.editorconfig index 39baa17..ab7e7f3 100644 --- a/.editorconfig +++ b/.editorconfig @@ -19,5 +19,6 @@ ij_kotlin_imports_layout = *,java.**,javax.**,kotlin.**,^ ij_kotlin_packages_to_use_import_on_demand = java.util.* #Ktlint ktlint_standard_no-wildcard-imports = disabled +ktlint_standard_package-name = disabled ktlint_code_style = official ktlint_ignore_back_ticked_identifier = false \ No newline at end of file diff --git a/.gitignore b/.gitignore index af65d03..a216726 100644 --- a/.gitignore +++ b/.gitignore @@ -25,4 +25,5 @@ hs_err_pid* !gradle-wrapper.jar !gradle-wrapper.properties -.DS_Store \ No newline at end of file +.DS_Store +codec.kt.tmp \ No newline at end of file diff --git a/scripts/packet_generate.py b/scripts/packet_generate.py new file mode 100644 index 0000000..e1bd0cd --- /dev/null +++ b/scripts/packet_generate.py @@ -0,0 +1,756 @@ +import re +import os +import requests + +kotlin_types_wrapper = { + "varint": { + "type": "Int", + "deserialize": "readVarInt()", + "serialize": "writeVarInt(%s)", + "comment": "varint" + }, + "optvarint": { + "type": "Int?", + "deserialize": "readVarInt()", + "serialize": "writeVarInt(%s)" + }, + "i8": { + "type": "Byte", + "deserialize": "readByte()", + "serialize": "writeByte(%s)" + }, + "u8": { + "type": "UByte", + "deserialize": "readUByte()", + "serialize": "writeUByte(%s)" + }, + "i16": { + "type": "Short", + "deserialize": "readShort()", + "serialize": "writeShort(%s)" + }, + "u16": { + "type": "UShort", + "deserialize": "readUShort()", + "serialize": "writeUShort(%s)" + }, + "i32": { + "type": "Int", + "deserialize": "readInt()", + "serialize": "writeInt(%s)" + }, + "i64": { + "type": "Long", + "deserialize": "readLong()", + "serialize": "writeLong(%s)" + }, + "bool": { + "type": "Boolean", + "deserialize": "readBoolean()", + "serialize": "writeBoolean(%s)" + }, + "f32": { + "type": "Float", + "deserialize": "readFloat()", + "serialize": "writeFloat(%s)" + }, + "f64": { + "type": "Double", + "deserialize": "readDouble()", + "serialize": "writeDouble(%s)" + }, + "UUID": { + "type": "UUID", + "deserialize": "readUUID()", + "serialize": "writeUUID(%s)", + "import": "import java.util.UUID" + }, + "string": { + "type": "String", + "deserialize": "readString()", + "serialize": "writeString(%s)" + }, + "entityMetadataLoop": "native", + "topBitSetTerminatedArray": "native", + "bitfield": "native", + "void": { + "type": "null", + "deserialize": "null", + "serialize": "null" + }, + "array": "native", + "buffer": { + "type": "ByteArray", + "deserialize": "readVarIntByteArray()", + "serialize": "writeVarIntByteArray(%s)" + }, + "restBuffer": { + "type": "ByteArray", + "deserialize": "readRemainingByteArray()", + "serialize": "writeRemainingByteArray(%s)" + }, + "nbt": { + "type": "ByteArray", + "deserialize": "readNBT()", + "serialize": "writeBytes(%s)" + }, + "optionalNbt": { + "type": "ByteArray", + "deserialize": "readNBT()", + "serialize": "writeBytes(%s)" + }, + "slot": "native", + "position": { + "type": "Position", + "deserialize": "readPosition()", + "serialize": "writePosition(%s)", + "import": "import io.layercraft.packetlib.types.Position" + }, + "entityMetadata": "native", + "previousMessages": "native", + "command_node": "native", + "chunkBlockEntity": "native", +} + +src = "src/main/kotlin" + +wikivg_url = "https://wiki.vg/index.php?title=Protocol" +wikivg_url_end = "&oldid=17873" +wikivg_text = requests.get(wikivg_url + wikivg_url_end).text + +data_url = "https://raw.githubusercontent.com/PrismarineJS/minecraft-data/master/data/pc/1.19.2/protocol.json" + +version = data_url.split("/")[-2] +version_underline = version.replace(".", "_") + +minecraft_codec = [] + +runs = 0 +runswitherror = 0 + + +def camel_case(s): + camel_case_str = re.sub(r"([-_])([a-zA-Z])", + lambda m: m.group(2).upper(), s) + camel_case_str = camel_case_str[0].lower() + camel_case_str[1:] + return camel_case_str + + +def codec_generate(): + handshakingText = "" + loginText = "" + statusText = "" + playText = "" + + for packet in minecraft_codec: + class_name = packet["class"] + package_string = packet["package"] + status = packet["status"] + id = packet["id"] + + direction_string = "registerClientBoundPacket" if packet[ + "direction"] == "clientbound" else "registerServerBoundPacket" + add_text = f""" .{direction_string}({id}, {package_string}.{class_name}::class, {package_string}.{class_name}) \n""" + + if status == "handshaking": + handshakingText += add_text + elif status == "login": + loginText += add_text + elif status == "status": + statusText += add_text + elif status == "play": + playText += add_text + + text = f""" + val V{version_underline}: MinecraftCodec = + MinecraftCodec.create(ProtocolVersion.V{version_underline}) + .registerPacketRegistry( + PacketState.HANDSHAKING, + MinecraftCodecRegistry.create() +{handshakingText}) + .registerPacketRegistry( + PacketState.LOGIN, + MinecraftCodecRegistry.create() +{loginText}) + .registerPacketRegistry( + PacketState.STATUS, + MinecraftCodecRegistry.create() +{statusText}) + .registerPacketRegistry( + PacketState.PLAY, + MinecraftCodecRegistry.create() +{playText}) + """ + + # write to codec.kt.tmp file + with open(f"codec.kt.tmp", "w+") as f: + f.write(text) + + +def transfer_packets(direction: str, status: str, data: dict): + packets_result = [] + + # Packet = data with "packet_" key + packets = {} + for packet in data: + if packet.startswith("packet_"): + packets[packet] = data[packet] + + packet_info = data["packet"][1] + packet_ids = [] + for ids in packet_info: + if ids["name"] == "name": + packet_ids = ids["type"][1]["mappings"] + break + + packet_names = [] + for names in packet_info: + if names["name"] == "params": + packet_names = names["type"][1]["fields"] + break + + # clear packet_info + packet_info = [] + + for id in packet_ids: + name = packet_ids[id] + packet_name = packet_names[name] + + packet_info.append({ + "id": id, + "name": name, + "packet_name": packet_name + }) + + for packet in packet_info: + id = packet["id"] + name = packet["name"] + packet_name = packet["packet_name"] + + packet_fields = packets[packet_name][1] + + packets_result.append({ + "id": id, + "name": name, + "fields": packet_fields, + "direction": direction, + "status": status + }) + + return packets_result + + +def packets(data: dict): + print("Generating packets...") + packets = [] + + for status in data: + if status == "types": + continue + + toClient = data[status]["toClient"]["types"] + toServer = data[status]["toServer"]["types"] + + clientbound = transfer_packets("clientbound", status, toClient) + serverbound = transfer_packets("serverbound", status, toServer) + + packets += clientbound + serverbound + + return packets + + handshakingText = "" + loginText = "" + statusText = "" + playText = "" + + for packet in minecraft_codec: + class_name = packet["class"] + package_string = packet["package"] + status = packet["status"] + id = packet["id"] + + direction_string = "registerClientBoundPacket" if packet[ + "direction"] == "clientbound" else "registerServerBoundPacket" + add_text = f""" .{direction_string}({id}, {package_string}.{class_name}::class, {package_string}.{class_name}) \n""" + + if status == "handshaking": + handshakingText += add_text + elif status == "login": + loginText += add_text + elif status == "status": + statusText += add_text + elif status == "play": + playText += add_text + + text = f""" + val V{version_underline}: MinecraftCodec = + MinecraftCodec.create(ProtocolVersion.V{version_underline}) + .registerPacketRegistry( + PacketState.HANDSHAKING, + MinecraftCodecRegistry.create() +{handshakingText}) + .registerPacketRegistry( + PacketState.LOGIN, + MinecraftCodecRegistry.create() +{loginText}) + .registerPacketRegistry( + PacketState.STATUS, + MinecraftCodecRegistry.create() +{statusText}) + .registerPacketRegistry( + PacketState.PLAY, + MinecraftCodecRegistry.create() +{playText}) + """ + + # write to codec.kt.tmp file + with open(f"codec.kt.tmp", "w+") as f: + f.write(text) + + +def add_run(): + global runs + runs += 1 + + +class PacketGenerator: + def __init__(self, packet_dict: dict): + self.packet = packet_dict + self.id = packet_dict['id'] + self.name = packet_dict['name'] + self.direction = packet_dict['direction'] + self.status = packet_dict["status"] + self.fields = packet_dict['fields'] + self.version = version + self.version_underline = version.replace(".", "_") + self.package = f"io.layercraft.packetlib.packets.v{self.version_underline}.{self.status}.{self.direction}" + self.package_path = f"io/layercraft/packetlib/packets/v{self.version_underline}/{self.status}/{self.direction}" + self.class_name = self.name.replace("_", " ").title().replace(" ", "") + "Packet" + wikivg_data = self.wikivg_data(self.id, self.status, self.direction) + self.wikivg_id = wikivg_data['id'] + self.wikivg_name = wikivg_data['name'] + + self.class_fields = [] + self.class_serialize = [] + self.class_deserialize = [] + self.class_var_list = [] + self.class_docs = [] + self.class_other_imports = [] + self.additional_class = "" + + def direction_interface(self): + if self.direction == "serverbound": + return "ServerBoundPacket" + elif self.direction == "clientbound": + return "ClientBoundPacket" + + def wikivg_data(self, packet_id: str, state: str, direction: str): + body_text = re.search('(.*?)', + wikivg_text, re.DOTALL).group(1) + + direction = "Client" if direction == "clientbound" else "Server" + state = state.capitalize() + regex = rf'{packet_id}\n\n{state}\n\n{direction}\n' + result = re.split(regex, body_text, re.DOTALL)[0] + result = result.split("

")[-1] + id = result.split('')[0] + name = result.split('">')[1].split("")[0] + + return { + "id": id, + "name": name + } + + def generate_basic_type(self, field_name: str, field_type: str, field_var_name: str): + kotlin_type = kotlin_types_wrapper[field_type] + field_comment = " // " + \ + kotlin_type["comment"] if "comment" in kotlin_type else "" + + if kotlin_type == "native": + add_run() + print("Not supported yet") + return + elif kotlin_type == "": + raise Exception("Not supported") + + kotlin_type_str = kotlin_type["type"] + kotlin_type_serialize = kotlin_type["serialize"] + kotlin_type_deserialize = kotlin_type["deserialize"] + + self.class_fields += [f"val {field_var_name}: {kotlin_type_str},{field_comment}"] + self.class_deserialize += [f"val {field_var_name} = input.{kotlin_type_deserialize}"] + + self.class_serialize += [f"output.{kotlin_type_serialize % ('value.' + field_var_name)}"] + + self.class_var_list += [field_var_name] + self.class_docs += [f" * @property {field_var_name} {field_name}"] + + if "import" in kotlin_type: + self.class_other_imports += [kotlin_type["import"]] + + def generate_option_basic_type(self, field_name: str, field_type: str, field_var_name: str): + kotlin_type = kotlin_types_wrapper[field_type] + + field_comment = (" // " + kotlin_type["comment"]) if "comment" in kotlin_type else "" + + boolean_field_var_name = ( + "has" + field_var_name[0].upper() + field_var_name[1:]) + + kotlin_type_str = kotlin_type["type"] + kotlin_type_serialize = kotlin_type["serialize"] + kotlin_type_deserialize = kotlin_type["deserialize"] + + self.class_fields += [f"val {boolean_field_var_name}: Boolean,"] + self.class_fields += [f"val {field_var_name}: {kotlin_type_str}?,{field_comment}"] + + self.class_deserialize += [f"val {boolean_field_var_name} = input.readBoolean()"] + self.class_deserialize += [ + f"val {field_var_name} = if ({boolean_field_var_name}) input.{kotlin_type_deserialize} else null"] + + self.class_serialize += [f"output.writeBoolean(value.{boolean_field_var_name})"] + self.class_serialize += [ + f"if (value.{boolean_field_var_name}) output.{kotlin_type_serialize % ('value.' + field_var_name + '!!')}"] + + self.class_var_list += [boolean_field_var_name, + field_var_name] + + self.class_docs += [f" * @property {boolean_field_var_name} {field_name} is present"] + self.class_docs += [f" * @property {field_var_name} {field_name}"] + + if "import" in kotlin_type: + self.class_other_imports += [kotlin_type["import"]] + + def generate_option_basic_type_custom(self, field_name: str, field_type: str, field_var_name: str, boolean_field_var_name: str): + kotlin_type = kotlin_types_wrapper[field_type] + + field_comment = (" // " + kotlin_type["comment"]) if "comment" in kotlin_type else "" + + kotlin_type_str = kotlin_type["type"] + kotlin_type_serialize = kotlin_type["serialize"] + kotlin_type_deserialize = kotlin_type["deserialize"] + + self.class_fields += [f"val {field_var_name}: {kotlin_type_str}?,{field_comment}"] + + self.class_deserialize += [f"val {field_var_name} = if ({boolean_field_var_name}) input.{kotlin_type_deserialize} else null"] + + self.class_serialize += [f"if (value.{boolean_field_var_name}) output.{kotlin_type_serialize % ('value.' + field_var_name+ '!!')}"] + + self.class_var_list += [field_var_name] + + self.class_docs += [f" * @property {field_var_name} {field_name}"] + + if "import" in kotlin_type: + self.class_other_imports += [kotlin_type["import"]] + + def generate_basic_type_array(self, field_name: str, array_type: str, field_var_name: str): + array_kotlin_type = kotlin_types_wrapper[array_type] + + if array_kotlin_type == "native": + add_run() + print("Not supported yet") + return + + kotlin_type_str = array_kotlin_type["type"] + kotlin_type_serialize = array_kotlin_type["serialize"] + kotlin_type_deserialize = array_kotlin_type["deserialize"] + + self.class_fields += [f"val {field_var_name}: List<{kotlin_type_str}>, // varint array"] + self.class_deserialize += [f"val {field_var_name} = input.readVarIntArray {{ arrayInput -> arrayInput.{kotlin_type_deserialize} }}"] + self.class_serialize += [f"output.writeVarIntArray(value.{field_var_name}) {{ arrayValue, arrayOutput -> arrayOutput.{kotlin_type_serialize % 'arrayValue'}}}"] + self.class_var_list += [field_var_name] + self.class_docs += [f" * @property {field_var_name} {field_name}"] + + if "import" in array_kotlin_type: + self.class_other_imports += [array_kotlin_type["import"]] + + def generate_array(self, field_name: str, array: dict, field_var_name: str): + count_type = array["countType"] + array_type = array["type"] + array_type_type = type(array_type) + + if count_type == "varint": + if array_type_type is str: + print("field_name: " + field_name) + self.generate_basic_type_array(field_name, array_type, field_var_name) + elif array_type_type is dict: + add_run() + print("Not supported yet") + else: + raise Exception("Not supported") + + def generate_option_container(self, container: list, parent_field_name: str, parent_field_var_name: str): + parent_field_boolean_var_name = ("has" + parent_field_var_name[0].upper() + parent_field_var_name[1:]) + + self.class_fields += [f"val {parent_field_boolean_var_name}: Boolean,"] + self.class_deserialize += [f"val {parent_field_boolean_var_name} = input.readBoolean()"] + self.class_serialize += [f"output.writeBoolean(value.{parent_field_boolean_var_name})"] + self.class_var_list += [parent_field_boolean_var_name] + self.class_docs += [f" * @property {parent_field_boolean_var_name} {parent_field_name} is present"] + + for field in container: + field_name = field['name'] + field_type = field['type'] + field_var_name = camel_case(field_name) + field_type_type = type(field_type) + + if field_type_type is str: + self.generate_option_basic_type_custom(field_name, field_type, field_var_name, parent_field_boolean_var_name) + elif field_type_type is list: + field_sub_type_name = field_type[0] + if field_sub_type_name == "buffer": + buffer_count_type = field_type[1]["countType"] + if buffer_count_type == "varint": + self.generate_option_basic_type_custom(field_name, "buffer", field_var_name, parent_field_boolean_var_name) + else: + raise Exception("Not supported") + elif field_sub_type_name == "array": + add_run() + print("Not supported yet") + else: + raise Exception("Not supported") + else: + raise Exception("Not supported") + + def generate_switch(self, field_name: str, field_var_name: str, switch: dict): + compare_to_field = switch["compareTo"] + compare_to_field_var_name = camel_case(compare_to_field) + default = switch["default"] if "default" in switch else None + fields = switch["fields"] + kotlin_type_fix = {} + + deserialize = [] + serialize = [] + + for field in fields: + field_key = field + field_value = fields[field] + field_type_type = type(field_value) + + if field_type_type is str: + field_var_name = camel_case(field_name) + kotlin_type = kotlin_types_wrapper[field_value] + + if field_value == "void": + deserialize += [f"{field_key} -> null"] + else: + kotlin_type_fix = kotlin_type + deserialize += [f"{field_key} -> input.{kotlin_type['deserialize']}"] + serialize += [f"{field_key} -> output.{kotlin_type['serialize'] % ('value.' + field_var_name + '!!')}"] + else: + print("Not supported yet") + add_run() + return + + if default is not None: + default_type = type(default) + if default_type is str: + default_kotlin_type = kotlin_types_wrapper[default] + if default == "void": + deserialize += ["else -> null"] + serialize += ["else -> {}"] + else: + kotlin_type_fix = default_kotlin_type + deserialize += [f"else -> input.{default_kotlin_type['deserialize']}"] + serialize += [f"else -> output.{default_kotlin_type['serialize'] % ('value.' + field_var_name + '!!')}"] + else: + print("Not supported yet") + add_run() + return + else: + deserialize += ["else -> null"] + serialize += ["else -> {}"] + + deserialize_str = "\n ".join(deserialize) + serialize_str = "\n ".join(serialize) + + deserialize_str = f"""val {field_var_name} = when ({compare_to_field_var_name}) {{ + {deserialize_str} + }}""" + + serialize_str = f"""when (value.{compare_to_field_var_name}) {{ + {serialize_str} + }}""" + + self.class_deserialize += [deserialize_str] + self.class_serialize += [serialize_str] + + kotlin_type_str = kotlin_type_fix["type"] + field_comment = (" // " + kotlin_type_fix["comment"]) if "comment" in kotlin_type_fix else "" + + self.class_fields += [f"val {field_var_name}: {kotlin_type_str}?,{field_comment}"] + + self.class_var_list += [field_var_name] + + self.class_docs += [f" * @property {field_var_name} {field_name}"] + + if "import" in kotlin_type_fix: + self.class_other_imports += [kotlin_type_fix["import"]] + + def generate_container(self, container: list): + for field in container: + field_name = field['name'] + field_type = field['type'] + field_var_name = camel_case(field_name) + field_type_type = type(field_type) + + if field_type_type is str: + self.generate_basic_type(field_name, field_type, field_var_name) + elif field_type_type is list: + field_sub_type_name = field_type[0] + if field_sub_type_name == "option": + field_sub_type_name = field_type[1] + field_sub_type_name_type = type(field_sub_type_name) + + if field_sub_type_name_type is str: + # Option basic type + self.generate_option_basic_type(field_name, field_sub_type_name, field_var_name) + elif field_sub_type_name_type is list: + field_sub_type_name = field_sub_type_name[0] + + if field_sub_type_name == "container": + # Option container + container = field_type[1][1] + self.generate_option_container(container, field_name, field_var_name) + continue + elif field_sub_type_name == "array": + # Option array + continue + else: + raise Exception("Not supported") + else: + raise Exception("Not supported") + elif field_sub_type_name == "switch": + print(field_type) + self.generate_switch(field_name, field_var_name, field_type[1]) + elif field_sub_type_name == "array": + # Array + self.generate_array(field_name, field_type[1], field_var_name) + elif field_sub_type_name == "buffer": + buffer_count_type = field_type[1]["countType"] + if buffer_count_type == "varint": + self.generate_basic_type(field_name, "buffer", field_var_name) + else: + raise Exception("Not supported") + else: + print("Not supported yet") + add_run() + else: + raise Exception("Not supported") + + def generate_fields_internal(self, fields: list): + self.generate_container(fields) + + def generate_fields(self): + self.generate_fields_internal(self.fields) + + class_fields_str = "\n ".join(self.class_fields) + class_serialize_str = "\n ".join(self.class_serialize) + class_deserialize_str = "\n ".join(self.class_deserialize) + class_var_list_str = ", ".join(self.class_var_list) + class_docs_str = "\n".join(self.class_docs) + class_other_imports_str = "\n".join(self.class_other_imports) + + return { + "class_fields_str": class_fields_str, + "class_serialize_str": class_serialize_str, + "class_deserialize_str": class_deserialize_str, + "class_var_list_str": class_var_list_str, + "class_documenation_str": class_docs_str, + "class_other_imports_str": class_other_imports_str + } + + def generate(self): + + print(f"Generate: {self.package}.{self.class_name} ({self.id})") + + fields = self.generate_fields() + + class_fields_str = fields["class_fields_str"] + class_serialize_str = fields["class_serialize_str"] + class_deserialize_str = fields["class_deserialize_str"] + class_var_list_str = fields["class_var_list_str"] + class_documenation_str = fields["class_documenation_str"] + class_other_imports_str = fields["class_other_imports_str"] + additional_class_str = self.additional_class + + wikivg_name = self.wikivg_name + wikivg_id = self.wikivg_id + + id = self.id + status = self.status + direction = self.direction + direction_interface = self.direction_interface() + + class_name = self.class_name + + class_str = f"""package {self.package} + +import io.layercraft.packetlib.packets.* +import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface +import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface +{class_other_imports_str} +/** + * {wikivg_name} | {id} | {status} | {direction} + * +{class_documenation_str} + * @see https://wiki.vg/Protocol#{wikivg_id} + */ + +@MinecraftPacket(id = {id}, state = PacketState.{status.upper()}, direction = PacketDirection.{direction.upper()}) +{"data" if len(class_fields_str) > 1 else ""} class {class_name}( + {class_fields_str} +) : {direction_interface} {{ + companion object : PacketSerializer<{class_name}> {{ + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): {class_name} {{ + {class_deserialize_str} + + return {class_name}({class_var_list_str}) + }} + + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: {class_name}) {{ + {class_serialize_str} + }} + }} +}} +{additional_class_str}""" + + minecraft_codec.append( + { + "id": id, + "direction": direction, + "status": status, + "class": class_name, + "package": self.package + } + ) + + print(f"Generated: {self.package}.{self.class_name} ({self.id})") + + return class_str + + def write(self): + filename = f"{src}/{self.package_path}/{self.class_name}.kt" + class_str = self.generate() + + os.makedirs(os.path.dirname(filename), exist_ok=True) + with open(filename, "w+") as file: + file.write(class_str) + + +# Main +if __name__ == "__main__": + print("Starting...") + general_data = requests.get(data_url).json() + + packet_data = packets(general_data) + + for packet in packet_data: + generator = PacketGenerator(packet) + generator.write() + + print("Done with Packet Generation!") + + print("Codec generation...") + codec_generate() + print("Done!") + print(runs) diff --git a/src/main/kotlin/io/layercraft/packetlib/TranslatorAPI.kt b/src/main/kotlin/io/layercraft/packetlib/TranslatorAPI.kt index 1ba22ba..421b887 100644 --- a/src/main/kotlin/io/layercraft/packetlib/TranslatorAPI.kt +++ b/src/main/kotlin/io/layercraft/packetlib/TranslatorAPI.kt @@ -12,21 +12,21 @@ object TranslatorAPI { fun decodeFromByteArray(bytes: ByteArray, serializer: PacketSerializer): T { val packetRead = ByteReadPacket(bytes) - return serializer.serialize(packetRead.minecraft) + return serializer.deserialize(packetRead.minecraft) } fun encodeToByteArray(value: T, serializer: PacketSerializer): ByteArray { val packetWrite = BytePacketBuilder() - serializer.deserialize(packetWrite.minecraft, value) + serializer.serialize(packetWrite.minecraft, value) return packetWrite.build().readBytes() } fun decodeFromInputWithCodec(input: Input, codec: MinecraftCodec, packetDirection: PacketDirection, packetState: PacketState, packetId: Int): Packet? { - return codec.getCodecPacket(packetDirection, packetState, packetId)?.packetSerializer?.serialize(input.minecraft) + return codec.getCodecPacket(packetDirection, packetState, packetId)?.packetSerializer?.deserialize(input.minecraft) } fun encodeToOutputWithCodec(value: Packet, codec: MinecraftCodec, output: Output) { - codec.getCodecPacketFromPacket(value)?.packetSerializer!!.deserialize(output.minecraft, value) + codec.getCodecPacketFromPacket(value)?.packetSerializer!!.serialize(output.minecraft, value) } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/PacketInterface.kt b/src/main/kotlin/io/layercraft/packetlib/packets/PacketInterface.kt index 2a2c6ff..78032ab 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/PacketInterface.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/PacketInterface.kt @@ -18,9 +18,9 @@ interface ClientBoundPacket : Packet { } interface PacketSerializer where T : Packet { - fun serialize(input: MinecraftProtocolDeserializeInterface<*>): T + fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): T - fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: T) + fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: T) } @Target(AnnotationTarget.CLASS) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/handshaking/serverbound/LegacyServerListPingPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/handshaking/serverbound/LegacyServerListPingPacket.kt index 8623daa..edd7aea 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/handshaking/serverbound/LegacyServerListPingPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/handshaking/serverbound/LegacyServerListPingPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class LegacyServerListPingPacket( val payload: UByte, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): LegacyServerListPingPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): LegacyServerListPingPacket { val payload = input.readUByte() return LegacyServerListPingPacket(payload) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: LegacyServerListPingPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: LegacyServerListPingPacket) { output.writeUByte(value.payload) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/handshaking/serverbound/SetProtocolPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/handshaking/serverbound/SetProtocolPacket.kt index 64ff21e..63376f9 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/handshaking/serverbound/SetProtocolPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/handshaking/serverbound/SetProtocolPacket.kt @@ -21,9 +21,8 @@ data class SetProtocolPacket( val serverPort: UShort, val nextState: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SetProtocolPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SetProtocolPacket { val protocolVersion = input.readVarInt() val serverHost = input.readString() val serverPort = input.readUShort() @@ -32,7 +31,7 @@ data class SetProtocolPacket( return SetProtocolPacket(protocolVersion, serverHost, serverPort, nextState) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SetProtocolPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SetProtocolPacket) { output.writeVarInt(value.protocolVersion) output.writeString(value.serverHost) output.writeUShort(value.serverPort) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/CompressPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/CompressPacket.kt index 73fd6de..540b0b8 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/CompressPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/CompressPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class CompressPacket( val threshold: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): CompressPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): CompressPacket { val threshold = input.readVarInt() return CompressPacket(threshold) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: CompressPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: CompressPacket) { output.writeVarInt(value.threshold) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/DisconnectPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/DisconnectPacket.kt index 7287d1d..e2e42f8 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/DisconnectPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/DisconnectPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class DisconnectPacket( val reason: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): DisconnectPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): DisconnectPacket { val reason = input.readString() return DisconnectPacket(reason) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: DisconnectPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: DisconnectPacket) { output.writeString(value.reason) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/EncryptionBeginPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/EncryptionBeginPacket.kt index 64aaeaf..131a013 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/EncryptionBeginPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/EncryptionBeginPacket.kt @@ -8,23 +8,30 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * Encryption Request | 0x01 | login | clientbound * * @property serverId serverId + * @property publicKey publicKey + * @property verifyToken verifyToken * @see https://wiki.vg/Protocol#Encryption_Request */ @MinecraftPacket(id = 0x01, state = PacketState.LOGIN, direction = PacketDirection.CLIENTBOUND) data class EncryptionBeginPacket( val serverId: String, + val publicKey: ByteArray, + val verifyToken: ByteArray, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EncryptionBeginPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EncryptionBeginPacket { val serverId = input.readString() + val publicKey = input.readVarIntByteArray() + val verifyToken = input.readVarIntByteArray() - return EncryptionBeginPacket(serverId) + return EncryptionBeginPacket(serverId, publicKey, verifyToken) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EncryptionBeginPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EncryptionBeginPacket) { output.writeString(value.serverId) + output.writeVarIntByteArray(value.publicKey) + output.writeVarIntByteArray(value.verifyToken) } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/LoginPluginRequestPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/LoginPluginRequestPacket.kt index 92f1497..e587506 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/LoginPluginRequestPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/LoginPluginRequestPacket.kt @@ -19,9 +19,8 @@ data class LoginPluginRequestPacket( val channel: String, val data: ByteArray, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): LoginPluginRequestPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): LoginPluginRequestPacket { val messageId = input.readVarInt() val channel = input.readString() val data = input.readRemainingByteArray() @@ -29,7 +28,7 @@ data class LoginPluginRequestPacket( return LoginPluginRequestPacket(messageId, channel, data) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: LoginPluginRequestPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: LoginPluginRequestPacket) { output.writeVarInt(value.messageId) output.writeString(value.channel) output.writeRemainingByteArray(value.data) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/SuccessPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/SuccessPacket.kt index 8414d47..4055a47 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/SuccessPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/clientbound/SuccessPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import java.util.UUID - /** * Login Success | 0x02 | login | clientbound * @@ -18,16 +17,15 @@ data class SuccessPacket( val uuid: UUID, val username: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SuccessPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SuccessPacket { val uuid = input.readUUID() val username = input.readString() return SuccessPacket(uuid, username) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SuccessPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SuccessPacket) { output.writeUUID(value.uuid) output.writeString(value.username) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/EncryptionBeginPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/EncryptionBeginPacket.kt index 085a491..dace1d3 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/EncryptionBeginPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/EncryptionBeginPacket.kt @@ -7,23 +7,26 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface /** * Encryption Response | 0x01 | login | serverbound * + * @property sharedSecret sharedSecret * @property hasVerifyToken hasVerifyToken * @see https://wiki.vg/Protocol#Encryption_Response */ @MinecraftPacket(id = 0x01, state = PacketState.LOGIN, direction = PacketDirection.SERVERBOUND) data class EncryptionBeginPacket( + val sharedSecret: ByteArray, val hasVerifyToken: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EncryptionBeginPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EncryptionBeginPacket { + val sharedSecret = input.readVarIntByteArray() val hasVerifyToken = input.readBoolean() - return EncryptionBeginPacket(hasVerifyToken) + return EncryptionBeginPacket(sharedSecret, hasVerifyToken) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EncryptionBeginPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EncryptionBeginPacket) { + output.writeVarIntByteArray(value.sharedSecret) output.writeBoolean(value.hasVerifyToken) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/LoginPluginResponsePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/LoginPluginResponsePacket.kt index daaaf81..632b111 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/LoginPluginResponsePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/LoginPluginResponsePacket.kt @@ -19,9 +19,8 @@ data class LoginPluginResponsePacket( val hasData: Boolean, val data: ByteArray?, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): LoginPluginResponsePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): LoginPluginResponsePacket { val messageId = input.readVarInt() val hasData = input.readBoolean() val data = if (hasData) input.readRemainingByteArray() else null @@ -29,7 +28,7 @@ data class LoginPluginResponsePacket( return LoginPluginResponsePacket(messageId, hasData, data) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: LoginPluginResponsePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: LoginPluginResponsePacket) { output.writeVarInt(value.messageId) output.writeBoolean(value.hasData) if (value.hasData) output.writeRemainingByteArray(value.data!!) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/LoginStartPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/LoginStartPacket.kt index e42625b..068c5bb 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/LoginStartPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/login/serverbound/LoginStartPacket.kt @@ -4,11 +4,14 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import java.util.UUID - /** * Login Start | 0x00 | login | serverbound * * @property username username + * @property hasSignature signature is present + * @property timestamp timestamp + * @property publicKey publicKey + * @property signature signature * @property hasPlayerUUID playerUUID is present * @property playerUUID playerUUID * @see https://wiki.vg/Protocol#Login_Start @@ -17,21 +20,32 @@ import java.util.UUID @MinecraftPacket(id = 0x00, state = PacketState.LOGIN, direction = PacketDirection.SERVERBOUND) data class LoginStartPacket( val username: String, + val hasSignature: Boolean, + val timestamp: Long?, + val publicKey: ByteArray?, + val signature: ByteArray?, val hasPlayerUUID: Boolean, val playerUUID: UUID?, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): LoginStartPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): LoginStartPacket { val username = input.readString() + val hasSignature = input.readBoolean() + val timestamp = if (hasSignature) input.readLong() else null + val publicKey = if (hasSignature) input.readVarIntByteArray() else null + val signature = if (hasSignature) input.readVarIntByteArray() else null val hasPlayerUUID = input.readBoolean() val playerUUID = if (hasPlayerUUID) input.readUUID() else null - return LoginStartPacket(username, hasPlayerUUID, playerUUID) + return LoginStartPacket(username, hasSignature, timestamp, publicKey, signature, hasPlayerUUID, playerUUID) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: LoginStartPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: LoginStartPacket) { output.writeString(value.username) + output.writeBoolean(value.hasSignature) + if (value.hasSignature) output.writeLong(value.timestamp!!) + if (value.hasSignature) output.writeVarIntByteArray(value.publicKey!!) + if (value.hasSignature) output.writeVarIntByteArray(value.signature!!) output.writeBoolean(value.hasPlayerUUID) if (value.hasPlayerUUID) output.writeUUID(value.playerUUID!!) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AbilitiesPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AbilitiesPacket.kt index 8ad8461..cfa3944 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AbilitiesPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AbilitiesPacket.kt @@ -19,9 +19,8 @@ data class AbilitiesPacket( val flyingSpeed: Float, val walkingSpeed: Float, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): AbilitiesPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): AbilitiesPacket { val flags = input.readByte() val flyingSpeed = input.readFloat() val walkingSpeed = input.readFloat() @@ -29,7 +28,7 @@ data class AbilitiesPacket( return AbilitiesPacket(flags, flyingSpeed, walkingSpeed) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: AbilitiesPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: AbilitiesPacket) { output.writeByte(value.flags) output.writeFloat(value.flyingSpeed) output.writeFloat(value.walkingSpeed) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AcknowledgePlayerDiggingPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AcknowledgePlayerDiggingPacket.kt index ed69912..fa33346 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AcknowledgePlayerDiggingPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AcknowledgePlayerDiggingPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class AcknowledgePlayerDiggingPacket( val sequenceId: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): AcknowledgePlayerDiggingPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): AcknowledgePlayerDiggingPacket { val sequenceId = input.readVarInt() return AcknowledgePlayerDiggingPacket(sequenceId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: AcknowledgePlayerDiggingPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: AcknowledgePlayerDiggingPacket) { output.writeVarInt(value.sequenceId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ActionBarPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ActionBarPacket.kt index eba81f4..1ba9af8 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ActionBarPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ActionBarPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class ActionBarPacket( val text: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ActionBarPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ActionBarPacket { val text = input.readString() return ActionBarPacket(text) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ActionBarPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ActionBarPacket) { output.writeString(value.text) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AdvancementsPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AdvancementsPacket.kt index 838546b..42dd83a 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AdvancementsPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AdvancementsPacket.kt @@ -8,23 +8,26 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * Update Advancements | 0x67 | play | clientbound * * @property reset reset + * @property identifiers identifiers * @see https://wiki.vg/Protocol#Update_Advancements */ @MinecraftPacket(id = 0x67, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) data class AdvancementsPacket( val reset: Boolean, + val identifiers: List, // varint array ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): AdvancementsPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): AdvancementsPacket { val reset = input.readBoolean() + val identifiers = input.readVarIntArray { arrayInput -> arrayInput.readString() } - return AdvancementsPacket(reset) + return AdvancementsPacket(reset, identifiers) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: AdvancementsPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: AdvancementsPacket) { output.writeBoolean(value.reset) + output.writeVarIntArray(value.identifiers) { arrayValue, arrayOutput -> arrayOutput.writeString(arrayValue) } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AnimationPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AnimationPacket.kt index 30a45f4..07638c6 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AnimationPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AnimationPacket.kt @@ -17,16 +17,15 @@ data class AnimationPacket( val entityId: Int, // varint val animation: UByte, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): AnimationPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): AnimationPacket { val entityId = input.readVarInt() val animation = input.readUByte() return AnimationPacket(entityId, animation) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: AnimationPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: AnimationPacket) { output.writeVarInt(value.entityId) output.writeUByte(value.animation) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AttachEntityPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AttachEntityPacket.kt index 1b67ee1..db40f64 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AttachEntityPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/AttachEntityPacket.kt @@ -17,16 +17,15 @@ data class AttachEntityPacket( val entityId: Int, val vehicleId: Int, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): AttachEntityPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): AttachEntityPacket { val entityId = input.readInt() val vehicleId = input.readInt() return AttachEntityPacket(entityId, vehicleId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: AttachEntityPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: AttachEntityPacket) { output.writeInt(value.entityId) output.writeInt(value.vehicleId) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockActionPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockActionPacket.kt index 4597f0c..fdfcdc9 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockActionPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockActionPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Block Action | 0x08 | play | clientbound * @@ -22,9 +21,8 @@ data class BlockActionPacket( val byte2: UByte, val blockId: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): BlockActionPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): BlockActionPacket { val location = input.readPosition() val byte1 = input.readUByte() val byte2 = input.readUByte() @@ -33,7 +31,7 @@ data class BlockActionPacket( return BlockActionPacket(location, byte1, byte2, blockId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: BlockActionPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: BlockActionPacket) { output.writePosition(value.location) output.writeUByte(value.byte1) output.writeUByte(value.byte2) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockBreakAnimationPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockBreakAnimationPacket.kt index a26b7c7..ab8a265 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockBreakAnimationPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockBreakAnimationPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Set Block Destroy Stage | 0x06 | play | clientbound * @@ -20,9 +19,8 @@ data class BlockBreakAnimationPacket( val location: Position, val destroyStage: Byte, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): BlockBreakAnimationPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): BlockBreakAnimationPacket { val entityId = input.readVarInt() val location = input.readPosition() val destroyStage = input.readByte() @@ -30,7 +28,7 @@ data class BlockBreakAnimationPacket( return BlockBreakAnimationPacket(entityId, location, destroyStage) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: BlockBreakAnimationPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: BlockBreakAnimationPacket) { output.writeVarInt(value.entityId) output.writePosition(value.location) output.writeByte(value.destroyStage) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockChangePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockChangePacket.kt index 46bd45c..4a454eb 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockChangePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BlockChangePacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Block Update | 0x09 | play | clientbound * @@ -18,16 +17,15 @@ data class BlockChangePacket( val location: Position, val type: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): BlockChangePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): BlockChangePacket { val location = input.readPosition() val type = input.readVarInt() return BlockChangePacket(location, type) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: BlockChangePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: BlockChangePacket) { output.writePosition(value.location) output.writeVarInt(value.type) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BossBarPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BossBarPacket.kt index d5cf828..7021fc6 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BossBarPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/BossBarPacket.kt @@ -4,12 +4,16 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import java.util.UUID - /** * Use Item | 0x0a | play | clientbound * * @property entityUUID entityUUID * @property action action + * @property title title + * @property health health + * @property color color + * @property dividers dividers + * @property flags flags * @see https://wiki.vg/Protocol#Use_Item */ @@ -17,19 +21,73 @@ import java.util.UUID data class BossBarPacket( val entityUUID: UUID, val action: Int, // varint + val title: String?, + val health: Float?, + val color: Int?, // varint + val dividers: Int?, // varint + val flags: UByte?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): BossBarPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): BossBarPacket { val entityUUID = input.readUUID() val action = input.readVarInt() + val title = when (action) { + 0 -> input.readString() + 3 -> input.readString() + else -> null + } + val health = when (action) { + 0 -> input.readFloat() + 2 -> input.readFloat() + else -> null + } + val color = when (action) { + 0 -> input.readVarInt() + 4 -> input.readVarInt() + else -> null + } + val dividers = when (action) { + 0 -> input.readVarInt() + 4 -> input.readVarInt() + else -> null + } + val flags = when (action) { + 0 -> input.readUByte() + 5 -> input.readUByte() + else -> null + } - return BossBarPacket(entityUUID, action) + return BossBarPacket(entityUUID, action, title, health, color, dividers, flags) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: BossBarPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: BossBarPacket) { output.writeUUID(value.entityUUID) output.writeVarInt(value.action) + when (value.action) { + 0 -> output.writeString(value.title!!) + 3 -> output.writeString(value.title!!) + else -> {} + } + when (value.action) { + 0 -> output.writeFloat(value.health!!) + 2 -> output.writeFloat(value.health!!) + else -> {} + } + when (value.action) { + 0 -> output.writeVarInt(value.color!!) + 4 -> output.writeVarInt(value.color!!) + else -> {} + } + when (value.action) { + 0 -> output.writeVarInt(value.dividers!!) + 4 -> output.writeVarInt(value.dividers!!) + else -> {} + } + when (value.action) { + 0 -> output.writeUByte(value.flags!!) + 5 -> output.writeUByte(value.flags!!) + else -> {} + } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CameraPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CameraPacket.kt index ff96b95..8522941 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CameraPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CameraPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class CameraPacket( val cameraId: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): CameraPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): CameraPacket { val cameraId = input.readVarInt() return CameraPacket(cameraId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: CameraPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: CameraPacket) { output.writeVarInt(value.cameraId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ChatPreviewPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ChatPreviewPacket.kt index 1bd15e9..042ff46 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ChatPreviewPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ChatPreviewPacket.kt @@ -19,9 +19,8 @@ data class ChatPreviewPacket( val hasMessage: Boolean, val message: String?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ChatPreviewPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ChatPreviewPacket { val queryId = input.readInt() val hasMessage = input.readBoolean() val message = if (hasMessage) input.readString() else null @@ -29,7 +28,7 @@ data class ChatPreviewPacket( return ChatPreviewPacket(queryId, hasMessage, message) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ChatPreviewPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ChatPreviewPacket) { output.writeInt(value.queryId) output.writeBoolean(value.hasMessage) if (value.hasMessage) output.writeString(value.message!!) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ChatSuggestionsPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ChatSuggestionsPacket.kt index a026e64..5eb3a8a 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ChatSuggestionsPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ChatSuggestionsPacket.kt @@ -8,23 +8,26 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * Chat Suggestions | 0x15 | play | clientbound * * @property action action + * @property entries entries * @see https://wiki.vg/Protocol#Chat_Suggestions */ @MinecraftPacket(id = 0x15, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) data class ChatSuggestionsPacket( val action: Int, // varint + val entries: List, // varint array ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ChatSuggestionsPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ChatSuggestionsPacket { val action = input.readVarInt() + val entries = input.readVarIntArray { arrayInput -> arrayInput.readString() } - return ChatSuggestionsPacket(action) + return ChatSuggestionsPacket(action, entries) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ChatSuggestionsPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ChatSuggestionsPacket) { output.writeVarInt(value.action) + output.writeVarIntArray(value.entries) { arrayValue, arrayOutput -> arrayOutput.writeString(arrayValue) } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ClearTitlesPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ClearTitlesPacket.kt index 18fda3e..d1d30a9 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ClearTitlesPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ClearTitlesPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class ClearTitlesPacket( val reset: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ClearTitlesPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ClearTitlesPacket { val reset = input.readBoolean() return ClearTitlesPacket(reset) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ClearTitlesPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ClearTitlesPacket) { output.writeBoolean(value.reset) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CloseWindowPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CloseWindowPacket.kt index 0a74545..c573aa6 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CloseWindowPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CloseWindowPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class CloseWindowPacket( val windowId: UByte, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): CloseWindowPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): CloseWindowPacket { val windowId = input.readUByte() return CloseWindowPacket(windowId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: CloseWindowPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: CloseWindowPacket) { output.writeUByte(value.windowId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CollectPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CollectPacket.kt index 749a4c8..c4111de 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CollectPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CollectPacket.kt @@ -19,9 +19,8 @@ data class CollectPacket( val collectorEntityId: Int, // varint val pickupItemCount: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): CollectPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): CollectPacket { val collectedEntityId = input.readVarInt() val collectorEntityId = input.readVarInt() val pickupItemCount = input.readVarInt() @@ -29,7 +28,7 @@ data class CollectPacket( return CollectPacket(collectedEntityId, collectorEntityId, pickupItemCount) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: CollectPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: CollectPacket) { output.writeVarInt(value.collectedEntityId) output.writeVarInt(value.collectorEntityId) output.writeVarInt(value.pickupItemCount) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CraftProgressBarPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CraftProgressBarPacket.kt index ae5cce0..edeca42 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CraftProgressBarPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CraftProgressBarPacket.kt @@ -19,9 +19,8 @@ data class CraftProgressBarPacket( val property: Short, val value: Short, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): CraftProgressBarPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): CraftProgressBarPacket { val windowId = input.readUByte() val property = input.readShort() val value = input.readShort() @@ -29,7 +28,7 @@ data class CraftProgressBarPacket( return CraftProgressBarPacket(windowId, property, value) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: CraftProgressBarPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: CraftProgressBarPacket) { output.writeUByte(value.windowId) output.writeShort(value.property) output.writeShort(value.value) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CraftRecipeResponsePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CraftRecipeResponsePacket.kt index 8c7f98a..cf019fc 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CraftRecipeResponsePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CraftRecipeResponsePacket.kt @@ -17,16 +17,15 @@ data class CraftRecipeResponsePacket( val windowId: Byte, val recipe: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): CraftRecipeResponsePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): CraftRecipeResponsePacket { val windowId = input.readByte() val recipe = input.readString() return CraftRecipeResponsePacket(windowId, recipe) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: CraftRecipeResponsePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: CraftRecipeResponsePacket) { output.writeByte(value.windowId) output.writeString(value.recipe) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CustomPayloadPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CustomPayloadPacket.kt index 1907050..173d3f4 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CustomPayloadPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/CustomPayloadPacket.kt @@ -17,16 +17,15 @@ data class CustomPayloadPacket( val channel: String, val data: ByteArray, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): CustomPayloadPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): CustomPayloadPacket { val channel = input.readString() val data = input.readRemainingByteArray() return CustomPayloadPacket(channel, data) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: CustomPayloadPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: CustomPayloadPacket) { output.writeString(value.channel) output.writeRemainingByteArray(value.data) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeathCombatEventPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeathCombatEventPacket.kt index 9c61c38..7f8f003 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeathCombatEventPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeathCombatEventPacket.kt @@ -19,9 +19,8 @@ data class DeathCombatEventPacket( val entityId: Int, val message: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): DeathCombatEventPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): DeathCombatEventPacket { val playerId = input.readVarInt() val entityId = input.readInt() val message = input.readString() @@ -29,7 +28,7 @@ data class DeathCombatEventPacket( return DeathCombatEventPacket(playerId, entityId, message) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: DeathCombatEventPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: DeathCombatEventPacket) { output.writeVarInt(value.playerId) output.writeInt(value.entityId) output.writeString(value.message) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeclareCommandsPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeclareCommandsPacket.kt index d4de100..6c5bebc 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeclareCommandsPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeclareCommandsPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class DeclareCommandsPacket( val rootIndex: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): DeclareCommandsPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): DeclareCommandsPacket { val rootIndex = input.readVarInt() return DeclareCommandsPacket(rootIndex) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: DeclareCommandsPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: DeclareCommandsPacket) { output.writeVarInt(value.rootIndex) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeclareRecipesPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeclareRecipesPacket.kt index 9fbb078..ec801b9 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeclareRecipesPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DeclareRecipesPacket.kt @@ -13,13 +13,12 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface @MinecraftPacket(id = 0x6a, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) class DeclareRecipesPacket() : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): DeclareRecipesPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): DeclareRecipesPacket { return DeclareRecipesPacket() } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: DeclareRecipesPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: DeclareRecipesPacket) { } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DifficultyPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DifficultyPacket.kt index 6b1f038..5133a5d 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DifficultyPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/DifficultyPacket.kt @@ -17,16 +17,15 @@ data class DifficultyPacket( val difficulty: UByte, val difficultyLocked: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): DifficultyPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): DifficultyPacket { val difficulty = input.readUByte() val difficultyLocked = input.readBoolean() return DifficultyPacket(difficulty, difficultyLocked) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: DifficultyPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: DifficultyPacket) { output.writeUByte(value.difficulty) output.writeBoolean(value.difficultyLocked) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EndCombatEventPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EndCombatEventPacket.kt index c627a66..4ae468f 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EndCombatEventPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EndCombatEventPacket.kt @@ -17,16 +17,15 @@ data class EndCombatEventPacket( val duration: Int, // varint val entityId: Int, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EndCombatEventPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EndCombatEventPacket { val duration = input.readVarInt() val entityId = input.readInt() return EndCombatEventPacket(duration, entityId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EndCombatEventPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EndCombatEventPacket) { output.writeVarInt(value.duration) output.writeInt(value.entityId) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EnterCombatEventPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EnterCombatEventPacket.kt index f12e03f..5f91c75 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EnterCombatEventPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EnterCombatEventPacket.kt @@ -13,13 +13,12 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface @MinecraftPacket(id = 0x35, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) class EnterCombatEventPacket() : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EnterCombatEventPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EnterCombatEventPacket { return EnterCombatEventPacket() } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EnterCombatEventPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EnterCombatEventPacket) { } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityDestroyPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityDestroyPacket.kt index 2b535a8..960bc91 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityDestroyPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityDestroyPacket.kt @@ -7,19 +7,23 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface /** * Use Item | 0x3b | play | clientbound * - + * @property entityIds entityIds * @see https://wiki.vg/Protocol#Use_Item */ @MinecraftPacket(id = 0x3b, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) -class EntityDestroyPacket() : ClientBoundPacket { - +data class EntityDestroyPacket( + val entityIds: List, // varint array +) : ClientBoundPacket { companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityDestroyPacket { - return EntityDestroyPacket() + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityDestroyPacket { + val entityIds = input.readVarIntArray { arrayInput -> arrayInput.readVarInt() } + + return EntityDestroyPacket(entityIds) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityDestroyPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityDestroyPacket) { + output.writeVarIntArray(value.entityIds) { arrayValue, arrayOutput -> arrayOutput.writeVarInt(arrayValue) } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityEffectPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityEffectPacket.kt index 5085f12..4420c60 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityEffectPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityEffectPacket.kt @@ -27,9 +27,8 @@ data class EntityEffectPacket( val hasFactorCodec: Boolean, val factorCodec: ByteArray?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityEffectPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityEffectPacket { val entityId = input.readVarInt() val effectId = input.readVarInt() val amplifier = input.readByte() @@ -41,7 +40,7 @@ data class EntityEffectPacket( return EntityEffectPacket(entityId, effectId, amplifier, duration, hideParticles, hasFactorCodec, factorCodec) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityEffectPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityEffectPacket) { output.writeVarInt(value.entityId) output.writeVarInt(value.effectId) output.writeByte(value.amplifier) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityEquipmentPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityEquipmentPacket.kt index e5c0d94..7c5259a 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityEquipmentPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityEquipmentPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class EntityEquipmentPacket( val entityId: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityEquipmentPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityEquipmentPacket { val entityId = input.readVarInt() return EntityEquipmentPacket(entityId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityEquipmentPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityEquipmentPacket) { output.writeVarInt(value.entityId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityHeadRotationPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityHeadRotationPacket.kt index faf1316..be26229 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityHeadRotationPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityHeadRotationPacket.kt @@ -17,16 +17,15 @@ data class EntityHeadRotationPacket( val entityId: Int, // varint val headYaw: Byte, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityHeadRotationPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityHeadRotationPacket { val entityId = input.readVarInt() val headYaw = input.readByte() return EntityHeadRotationPacket(entityId, headYaw) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityHeadRotationPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityHeadRotationPacket) { output.writeVarInt(value.entityId) output.writeByte(value.headYaw) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityLookPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityLookPacket.kt index 83dfce3..ead7fed 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityLookPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityLookPacket.kt @@ -21,9 +21,8 @@ data class EntityLookPacket( val pitch: Byte, val onGround: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityLookPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityLookPacket { val entityId = input.readVarInt() val yaw = input.readByte() val pitch = input.readByte() @@ -32,7 +31,7 @@ data class EntityLookPacket( return EntityLookPacket(entityId, yaw, pitch, onGround) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityLookPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityLookPacket) { output.writeVarInt(value.entityId) output.writeByte(value.yaw) output.writeByte(value.pitch) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityMetadataPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityMetadataPacket.kt index a6e57a9..4ad3b54 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityMetadataPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityMetadataPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class EntityMetadataPacket( val entityId: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityMetadataPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityMetadataPacket { val entityId = input.readVarInt() return EntityMetadataPacket(entityId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityMetadataPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityMetadataPacket) { output.writeVarInt(value.entityId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityMoveLookPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityMoveLookPacket.kt index c3c143b..b145900 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityMoveLookPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityMoveLookPacket.kt @@ -27,9 +27,8 @@ data class EntityMoveLookPacket( val pitch: Byte, val onGround: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityMoveLookPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityMoveLookPacket { val entityId = input.readVarInt() val dX = input.readShort() val dY = input.readShort() @@ -41,7 +40,7 @@ data class EntityMoveLookPacket( return EntityMoveLookPacket(entityId, dX, dY, dZ, yaw, pitch, onGround) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityMoveLookPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityMoveLookPacket) { output.writeVarInt(value.entityId) output.writeShort(value.dX) output.writeShort(value.dY) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntitySoundEffectPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntitySoundEffectPacket.kt index 09fdb82..1770fc5 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntitySoundEffectPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntitySoundEffectPacket.kt @@ -23,9 +23,8 @@ data class EntitySoundEffectPacket( val volume: Float, val pitch: Float, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntitySoundEffectPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntitySoundEffectPacket { val soundId = input.readVarInt() val soundCategory = input.readVarInt() val entityId = input.readVarInt() @@ -35,7 +34,7 @@ data class EntitySoundEffectPacket( return EntitySoundEffectPacket(soundId, soundCategory, entityId, volume, pitch) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntitySoundEffectPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntitySoundEffectPacket) { output.writeVarInt(value.soundId) output.writeVarInt(value.soundCategory) output.writeVarInt(value.entityId) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityStatusPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityStatusPacket.kt index cd79d07..9390e16 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityStatusPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityStatusPacket.kt @@ -17,16 +17,15 @@ data class EntityStatusPacket( val entityId: Int, val entityStatus: Byte, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityStatusPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityStatusPacket { val entityId = input.readInt() val entityStatus = input.readByte() return EntityStatusPacket(entityId, entityStatus) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityStatusPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityStatusPacket) { output.writeInt(value.entityId) output.writeByte(value.entityStatus) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityTeleportPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityTeleportPacket.kt index 658980d..12fd3ac 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityTeleportPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityTeleportPacket.kt @@ -27,9 +27,8 @@ data class EntityTeleportPacket( val pitch: Byte, val onGround: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityTeleportPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityTeleportPacket { val entityId = input.readVarInt() val x = input.readDouble() val y = input.readDouble() @@ -41,7 +40,7 @@ data class EntityTeleportPacket( return EntityTeleportPacket(entityId, x, y, z, yaw, pitch, onGround) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityTeleportPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityTeleportPacket) { output.writeVarInt(value.entityId) output.writeDouble(value.x) output.writeDouble(value.y) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityUpdateAttributesPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityUpdateAttributesPacket.kt index 74a1988..599b3a4 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityUpdateAttributesPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityUpdateAttributesPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class EntityUpdateAttributesPacket( val entityId: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityUpdateAttributesPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityUpdateAttributesPacket { val entityId = input.readVarInt() return EntityUpdateAttributesPacket(entityId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityUpdateAttributesPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityUpdateAttributesPacket) { output.writeVarInt(value.entityId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityVelocityPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityVelocityPacket.kt index e450c73..b9a4992 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityVelocityPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/EntityVelocityPacket.kt @@ -21,9 +21,8 @@ data class EntityVelocityPacket( val velocityY: Short, val velocityZ: Short, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityVelocityPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityVelocityPacket { val entityId = input.readVarInt() val velocityX = input.readShort() val velocityY = input.readShort() @@ -32,7 +31,7 @@ data class EntityVelocityPacket( return EntityVelocityPacket(entityId, velocityX, velocityY, velocityZ) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityVelocityPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityVelocityPacket) { output.writeVarInt(value.entityId) output.writeShort(value.velocityX) output.writeShort(value.velocityY) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ExperiencePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ExperiencePacket.kt index 5251010..0fc0a70 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ExperiencePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ExperiencePacket.kt @@ -19,9 +19,8 @@ data class ExperiencePacket( val level: Int, // varint val totalExperience: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ExperiencePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ExperiencePacket { val experienceBar = input.readFloat() val level = input.readVarInt() val totalExperience = input.readVarInt() @@ -29,7 +28,7 @@ data class ExperiencePacket( return ExperiencePacket(experienceBar, level, totalExperience) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ExperiencePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ExperiencePacket) { output.writeFloat(value.experienceBar) output.writeVarInt(value.level) output.writeVarInt(value.totalExperience) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ExplosionPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ExplosionPacket.kt index 3c05c44..24b6086 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ExplosionPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ExplosionPacket.kt @@ -27,9 +27,8 @@ data class ExplosionPacket( val playerMotionY: Float, val playerMotionZ: Float, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ExplosionPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ExplosionPacket { val x = input.readFloat() val y = input.readFloat() val z = input.readFloat() @@ -41,7 +40,7 @@ data class ExplosionPacket( return ExplosionPacket(x, y, z, radius, playerMotionX, playerMotionY, playerMotionZ) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ExplosionPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ExplosionPacket) { output.writeFloat(value.x) output.writeFloat(value.y) output.writeFloat(value.z) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/FacePlayerPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/FacePlayerPacket.kt index 9d7e8fe..a23861e 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/FacePlayerPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/FacePlayerPacket.kt @@ -12,6 +12,8 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * @property y y * @property z z * @property isEntity isEntity + * @property entityId entityId + * @property entityFeetEyes entity_feet_eyes * @see https://wiki.vg/Protocol#Look_At */ @@ -22,25 +24,42 @@ data class FacePlayerPacket( val y: Double, val z: Double, val isEntity: Boolean, + val entityId: Int?, // varint + val entityFeetEyes: String?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): FacePlayerPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): FacePlayerPacket { val feetEyes = input.readVarInt() val x = input.readDouble() val y = input.readDouble() val z = input.readDouble() val isEntity = input.readBoolean() + val entityId = when (isEntity) { + true -> input.readVarInt() + else -> null + } + val entityFeetEyes = when (isEntity) { + true -> input.readString() + else -> null + } - return FacePlayerPacket(feetEyes, x, y, z, isEntity) + return FacePlayerPacket(feetEyes, x, y, z, isEntity, entityId, entityFeetEyes) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: FacePlayerPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: FacePlayerPacket) { output.writeVarInt(value.feetEyes) output.writeDouble(value.x) output.writeDouble(value.y) output.writeDouble(value.z) output.writeBoolean(value.isEntity) + when (value.isEntity) { + true -> output.writeVarInt(value.entityId!!) + else -> {} + } + when (value.isEntity) { + true -> output.writeString(value.entityFeetEyes!!) + else -> {} + } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/GameStateChangePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/GameStateChangePacket.kt index 2c5af7c..fe68afd 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/GameStateChangePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/GameStateChangePacket.kt @@ -17,16 +17,15 @@ data class GameStateChangePacket( val reason: UByte, val gameMode: Float, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): GameStateChangePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): GameStateChangePacket { val reason = input.readUByte() val gameMode = input.readFloat() return GameStateChangePacket(reason, gameMode) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: GameStateChangePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: GameStateChangePacket) { output.writeUByte(value.reason) output.writeFloat(value.gameMode) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/HeldItemSlotPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/HeldItemSlotPacket.kt index d9eb20e..9457714 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/HeldItemSlotPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/HeldItemSlotPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class HeldItemSlotPacket( val slot: Byte, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): HeldItemSlotPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): HeldItemSlotPacket { val slot = input.readByte() return HeldItemSlotPacket(slot) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: HeldItemSlotPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: HeldItemSlotPacket) { output.writeByte(value.slot) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/HideMessagePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/HideMessagePacket.kt index 952ba3c..c6f2b2a 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/HideMessagePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/HideMessagePacket.kt @@ -7,19 +7,23 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface /** * Hide Message | 0x18 | play | clientbound * - + * @property signature signature * @see https://wiki.vg/Protocol#Hide_Message */ @MinecraftPacket(id = 0x18, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) -class HideMessagePacket() : ClientBoundPacket { - +data class HideMessagePacket( + val signature: List, // varint array +) : ClientBoundPacket { companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): HideMessagePacket { - return HideMessagePacket() + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): HideMessagePacket { + val signature = input.readVarIntArray { arrayInput -> arrayInput.readUByte() } + + return HideMessagePacket(signature) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: HideMessagePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: HideMessagePacket) { + output.writeVarIntArray(value.signature) { arrayValue, arrayOutput -> arrayOutput.writeUByte(arrayValue) } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/InitializeWorldBorderPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/InitializeWorldBorderPacket.kt index 8f6a37b..8b33ae3 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/InitializeWorldBorderPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/InitializeWorldBorderPacket.kt @@ -29,9 +29,8 @@ data class InitializeWorldBorderPacket( val warningBlocks: Int, // varint val warningTime: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): InitializeWorldBorderPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): InitializeWorldBorderPacket { val x = input.readDouble() val z = input.readDouble() val oldDiameter = input.readDouble() @@ -44,7 +43,7 @@ data class InitializeWorldBorderPacket( return InitializeWorldBorderPacket(x, z, oldDiameter, newDiameter, speed, portalTeleportBoundary, warningBlocks, warningTime) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: InitializeWorldBorderPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: InitializeWorldBorderPacket) { output.writeDouble(value.x) output.writeDouble(value.z) output.writeDouble(value.oldDiameter) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/KeepAlivePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/KeepAlivePacket.kt index 0b67dfc..65f91ee 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/KeepAlivePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/KeepAlivePacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class KeepAlivePacket( val keepAliveId: Long, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): KeepAlivePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): KeepAlivePacket { val keepAliveId = input.readLong() return KeepAlivePacket(keepAliveId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: KeepAlivePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: KeepAlivePacket) { output.writeLong(value.keepAliveId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/KickDisconnectPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/KickDisconnectPacket.kt index 7515208..35d8299 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/KickDisconnectPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/KickDisconnectPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class KickDisconnectPacket( val reason: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): KickDisconnectPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): KickDisconnectPacket { val reason = input.readString() return KickDisconnectPacket(reason) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: KickDisconnectPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: KickDisconnectPacket) { output.writeString(value.reason) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/LoginPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/LoginPacket.kt index 363c603..9f2925a 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/LoginPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/LoginPacket.kt @@ -3,7 +3,7 @@ package io.layercraft.packetlib.packets.v1_19_2.play.clientbound import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface - +import io.layercraft.packetlib.types.Position /** * | 0x25 | play | clientbound * @@ -11,6 +11,7 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * @property isHardcore isHardcore * @property gameMode gameMode * @property previousGameMode previousGameMode + * @property worldNames worldNames * @property dimensionCodec dimensionCodec * @property worldType worldType * @property worldName worldName @@ -22,6 +23,9 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * @property enableRespawnScreen enableRespawnScreen * @property isDebug isDebug * @property isFlat isFlat + * @property hasDeath death is present + * @property dimensionName dimensionName + * @property location location * @see https://wiki.vg/Protocol#Login_.28play.29 */ @@ -31,6 +35,7 @@ data class LoginPacket( val isHardcore: Boolean, val gameMode: UByte, val previousGameMode: Byte, + val worldNames: List, // varint array val dimensionCodec: ByteArray, val worldType: String, val worldName: String, @@ -42,14 +47,17 @@ data class LoginPacket( val enableRespawnScreen: Boolean, val isDebug: Boolean, val isFlat: Boolean, + val hasDeath: Boolean, + val dimensionName: String?, + val location: Position?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): LoginPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): LoginPacket { val entityId = input.readInt() val isHardcore = input.readBoolean() val gameMode = input.readUByte() val previousGameMode = input.readByte() + val worldNames = input.readVarIntArray { arrayInput -> arrayInput.readString() } val dimensionCodec = input.readNBT() val worldType = input.readString() val worldName = input.readString() @@ -61,15 +69,19 @@ data class LoginPacket( val enableRespawnScreen = input.readBoolean() val isDebug = input.readBoolean() val isFlat = input.readBoolean() + val hasDeath = input.readBoolean() + val dimensionName = if (hasDeath) input.readString() else null + val location = if (hasDeath) input.readPosition() else null - return LoginPacket(entityId, isHardcore, gameMode, previousGameMode, dimensionCodec, worldType, worldName, hashedSeed, maxPlayers, viewDistance, simulationDistance, reducedDebugInfo, enableRespawnScreen, isDebug, isFlat) + return LoginPacket(entityId, isHardcore, gameMode, previousGameMode, worldNames, dimensionCodec, worldType, worldName, hashedSeed, maxPlayers, viewDistance, simulationDistance, reducedDebugInfo, enableRespawnScreen, isDebug, isFlat, hasDeath, dimensionName, location) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: LoginPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: LoginPacket) { output.writeInt(value.entityId) output.writeBoolean(value.isHardcore) output.writeUByte(value.gameMode) output.writeByte(value.previousGameMode) + output.writeVarIntArray(value.worldNames) { arrayValue, arrayOutput -> arrayOutput.writeString(arrayValue) } output.writeBytes(value.dimensionCodec) output.writeString(value.worldType) output.writeString(value.worldName) @@ -81,6 +93,9 @@ data class LoginPacket( output.writeBoolean(value.enableRespawnScreen) output.writeBoolean(value.isDebug) output.writeBoolean(value.isFlat) + output.writeBoolean(value.hasDeath) + if (value.hasDeath) output.writeString(value.dimensionName!!) + if (value.hasDeath) output.writePosition(value.location!!) } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MapChunkPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MapChunkPacket.kt index e80aaa1..9cec1b3 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MapChunkPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MapChunkPacket.kt @@ -10,7 +10,12 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * @property x x * @property z z * @property heightmaps heightmaps + * @property chunkData chunkData * @property trustEdges trustEdges + * @property skyLightMask skyLightMask + * @property blockLightMask blockLightMask + * @property emptySkyLightMask emptySkyLightMask + * @property emptyBlockLightMask emptyBlockLightMask * @see https://wiki.vg/Protocol#Chunk_Data_and_Update_Light */ @@ -19,24 +24,38 @@ data class MapChunkPacket( val x: Int, val z: Int, val heightmaps: ByteArray, + val chunkData: ByteArray, val trustEdges: Boolean, + val skyLightMask: List, // varint array + val blockLightMask: List, // varint array + val emptySkyLightMask: List, // varint array + val emptyBlockLightMask: List, // varint array ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): MapChunkPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): MapChunkPacket { val x = input.readInt() val z = input.readInt() val heightmaps = input.readNBT() + val chunkData = input.readVarIntByteArray() val trustEdges = input.readBoolean() + val skyLightMask = input.readVarIntArray { arrayInput -> arrayInput.readLong() } + val blockLightMask = input.readVarIntArray { arrayInput -> arrayInput.readLong() } + val emptySkyLightMask = input.readVarIntArray { arrayInput -> arrayInput.readLong() } + val emptyBlockLightMask = input.readVarIntArray { arrayInput -> arrayInput.readLong() } - return MapChunkPacket(x, z, heightmaps, trustEdges) + return MapChunkPacket(x, z, heightmaps, chunkData, trustEdges, skyLightMask, blockLightMask, emptySkyLightMask, emptyBlockLightMask) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: MapChunkPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: MapChunkPacket) { output.writeInt(value.x) output.writeInt(value.z) output.writeBytes(value.heightmaps) + output.writeVarIntByteArray(value.chunkData) output.writeBoolean(value.trustEdges) + output.writeVarIntArray(value.skyLightMask) { arrayValue, arrayOutput -> arrayOutput.writeLong(arrayValue) } + output.writeVarIntArray(value.blockLightMask) { arrayValue, arrayOutput -> arrayOutput.writeLong(arrayValue) } + output.writeVarIntArray(value.emptySkyLightMask) { arrayValue, arrayOutput -> arrayOutput.writeLong(arrayValue) } + output.writeVarIntArray(value.emptyBlockLightMask) { arrayValue, arrayOutput -> arrayOutput.writeLong(arrayValue) } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MapPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MapPacket.kt index 407d69b..5a89597 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MapPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MapPacket.kt @@ -11,6 +11,9 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * @property scale scale * @property locked locked * @property columns columns + * @property rows rows + * @property x x + * @property y y * @see https://wiki.vg/Protocol#Map_Data */ @@ -20,23 +23,46 @@ data class MapPacket( val scale: Byte, val locked: Boolean, val columns: UByte, + val rows: UByte?, + val x: UByte?, + val y: UByte?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): MapPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): MapPacket { val itemDamage = input.readVarInt() val scale = input.readByte() val locked = input.readBoolean() val columns = input.readUByte() + val rows = when (columns.toInt()) { + 0 -> null + else -> input.readUByte() + } + val x = when (columns.toInt()) { + 0 -> null + else -> input.readUByte() + } + val y = when (columns.toInt()) { + 0 -> null + else -> input.readUByte() + } - return MapPacket(itemDamage, scale, locked, columns) + return MapPacket(itemDamage, scale, locked, columns, rows, x, y) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: MapPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: MapPacket) { output.writeVarInt(value.itemDamage) output.writeByte(value.scale) output.writeBoolean(value.locked) output.writeUByte(value.columns) + when (value.columns) { + else -> output.writeUByte(value.rows!!) + } + when (value.columns) { + else -> output.writeUByte(value.x!!) + } + when (value.columns) { + else -> output.writeUByte(value.y!!) + } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MessageHeaderPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MessageHeaderPacket.kt index 66cd481..b0dbc80 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MessageHeaderPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MessageHeaderPacket.kt @@ -4,28 +4,34 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import java.util.UUID - /** * Message Header | 0x32 | play | clientbound * * @property senderUuid senderUuid + * @property headerSignature headerSignature + * @property bodyDigest bodyDigest * @see https://wiki.vg/Protocol#Message_Header */ @MinecraftPacket(id = 0x32, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) data class MessageHeaderPacket( val senderUuid: UUID, + val headerSignature: List, // varint array + val bodyDigest: List, // varint array ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): MessageHeaderPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): MessageHeaderPacket { val senderUuid = input.readUUID() + val headerSignature = input.readVarIntArray { arrayInput -> arrayInput.readUByte() } + val bodyDigest = input.readVarIntArray { arrayInput -> arrayInput.readUByte() } - return MessageHeaderPacket(senderUuid) + return MessageHeaderPacket(senderUuid, headerSignature, bodyDigest) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: MessageHeaderPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: MessageHeaderPacket) { output.writeUUID(value.senderUuid) + output.writeVarIntArray(value.headerSignature) { arrayValue, arrayOutput -> arrayOutput.writeUByte(arrayValue) } + output.writeVarIntArray(value.bodyDigest) { arrayValue, arrayOutput -> arrayOutput.writeUByte(arrayValue) } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MultiBlockChangePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MultiBlockChangePacket.kt index 622cfe4..342f906 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MultiBlockChangePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/MultiBlockChangePacket.kt @@ -8,23 +8,26 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * Update Section Blocks | 0x40 | play | clientbound * * @property suppressLightUpdates suppressLightUpdates + * @property records records * @see https://wiki.vg/Protocol#Update_Section_Blocks */ @MinecraftPacket(id = 0x40, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) data class MultiBlockChangePacket( val suppressLightUpdates: Boolean, + val records: List, // varint array ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): MultiBlockChangePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): MultiBlockChangePacket { val suppressLightUpdates = input.readBoolean() + val records = input.readVarIntArray { arrayInput -> arrayInput.readVarInt() } - return MultiBlockChangePacket(suppressLightUpdates) + return MultiBlockChangePacket(suppressLightUpdates, records) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: MultiBlockChangePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: MultiBlockChangePacket) { output.writeBoolean(value.suppressLightUpdates) + output.writeVarIntArray(value.records) { arrayValue, arrayOutput -> arrayOutput.writeVarInt(arrayValue) } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NamedEntitySpawnPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NamedEntitySpawnPacket.kt index 45d85a5..0a137aa 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NamedEntitySpawnPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NamedEntitySpawnPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import java.util.UUID - /** * Spawn Player | 0x02 | play | clientbound * @@ -28,9 +27,8 @@ data class NamedEntitySpawnPacket( val yaw: Byte, val pitch: Byte, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): NamedEntitySpawnPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): NamedEntitySpawnPacket { val entityId = input.readVarInt() val playerUUID = input.readUUID() val x = input.readDouble() @@ -42,7 +40,7 @@ data class NamedEntitySpawnPacket( return NamedEntitySpawnPacket(entityId, playerUUID, x, y, z, yaw, pitch) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: NamedEntitySpawnPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: NamedEntitySpawnPacket) { output.writeVarInt(value.entityId) output.writeUUID(value.playerUUID) output.writeDouble(value.x) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NamedSoundEffectPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NamedSoundEffectPacket.kt index cd9b4a2..4cdffef 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NamedSoundEffectPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NamedSoundEffectPacket.kt @@ -29,9 +29,8 @@ data class NamedSoundEffectPacket( val pitch: Float, val seed: Long, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): NamedSoundEffectPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): NamedSoundEffectPacket { val soundName = input.readString() val soundCategory = input.readVarInt() val x = input.readInt() @@ -44,7 +43,7 @@ data class NamedSoundEffectPacket( return NamedSoundEffectPacket(soundName, soundCategory, x, y, z, volume, pitch, seed) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: NamedSoundEffectPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: NamedSoundEffectPacket) { output.writeString(value.soundName) output.writeVarInt(value.soundCategory) output.writeInt(value.x) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NbtQueryResponsePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NbtQueryResponsePacket.kt index 5172e3d..aa2e42c 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NbtQueryResponsePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/NbtQueryResponsePacket.kt @@ -17,16 +17,15 @@ data class NbtQueryResponsePacket( val transactionId: Int, // varint val nbt: ByteArray, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): NbtQueryResponsePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): NbtQueryResponsePacket { val transactionId = input.readVarInt() val nbt = input.readNBT() return NbtQueryResponsePacket(transactionId, nbt) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: NbtQueryResponsePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: NbtQueryResponsePacket) { output.writeVarInt(value.transactionId) output.writeBytes(value.nbt) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenBookPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenBookPacket.kt index 3c3df1f..91db6da 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenBookPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenBookPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class OpenBookPacket( val hand: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): OpenBookPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): OpenBookPacket { val hand = input.readVarInt() return OpenBookPacket(hand) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: OpenBookPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: OpenBookPacket) { output.writeVarInt(value.hand) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenHorseWindowPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenHorseWindowPacket.kt index 21a9172..2241e95 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenHorseWindowPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenHorseWindowPacket.kt @@ -19,9 +19,8 @@ data class OpenHorseWindowPacket( val nbSlots: Int, // varint val entityId: Int, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): OpenHorseWindowPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): OpenHorseWindowPacket { val windowId = input.readUByte() val nbSlots = input.readVarInt() val entityId = input.readInt() @@ -29,7 +28,7 @@ data class OpenHorseWindowPacket( return OpenHorseWindowPacket(windowId, nbSlots, entityId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: OpenHorseWindowPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: OpenHorseWindowPacket) { output.writeUByte(value.windowId) output.writeVarInt(value.nbSlots) output.writeInt(value.entityId) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenSignEntityPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenSignEntityPacket.kt index a9ba4f0..db6dba9 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenSignEntityPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenSignEntityPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Use Item | 0x2e | play | clientbound * @@ -16,15 +15,14 @@ import io.layercraft.packetlib.types.Position data class OpenSignEntityPacket( val location: Position, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): OpenSignEntityPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): OpenSignEntityPacket { val location = input.readPosition() return OpenSignEntityPacket(location) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: OpenSignEntityPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: OpenSignEntityPacket) { output.writePosition(value.location) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenWindowPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenWindowPacket.kt index dee31be..fbb6b69 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenWindowPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/OpenWindowPacket.kt @@ -19,9 +19,8 @@ data class OpenWindowPacket( val inventoryType: Int, // varint val windowTitle: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): OpenWindowPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): OpenWindowPacket { val windowId = input.readVarInt() val inventoryType = input.readVarInt() val windowTitle = input.readString() @@ -29,7 +28,7 @@ data class OpenWindowPacket( return OpenWindowPacket(windowId, inventoryType, windowTitle) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: OpenWindowPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: OpenWindowPacket) { output.writeVarInt(value.windowId) output.writeVarInt(value.inventoryType) output.writeString(value.windowTitle) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PingPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PingPacket.kt index fcedc52..d1cc039 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PingPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PingPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class PingPacket( val id: Int, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PingPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PingPacket { val id = input.readInt() return PingPacket(id) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PingPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PingPacket) { output.writeInt(value.id) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerChatPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerChatPacket.kt index b8f47f3..6642a3e 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerChatPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerChatPacket.kt @@ -4,11 +4,11 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import java.util.UUID - /** * Player Chat Message | 0x33 | play | clientbound * * @property senderUuid senderUuid + * @property headerSignature headerSignature * @property plainMessage plainMessage * @property hasFormattedMessage formattedMessage is present * @property formattedMessage formattedMessage @@ -27,6 +27,7 @@ import java.util.UUID @MinecraftPacket(id = 0x33, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) data class PlayerChatPacket( val senderUuid: UUID, + val headerSignature: List, // varint array val plainMessage: String, val hasFormattedMessage: Boolean, val formattedMessage: String?, @@ -40,10 +41,10 @@ data class PlayerChatPacket( val hasNetworkTargetName: Boolean, val networkTargetName: String?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PlayerChatPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PlayerChatPacket { val senderUuid = input.readUUID() + val headerSignature = input.readVarIntArray { arrayInput -> arrayInput.readUByte() } val plainMessage = input.readString() val hasFormattedMessage = input.readBoolean() val formattedMessage = if (hasFormattedMessage) input.readString() else null @@ -57,11 +58,12 @@ data class PlayerChatPacket( val hasNetworkTargetName = input.readBoolean() val networkTargetName = if (hasNetworkTargetName) input.readString() else null - return PlayerChatPacket(senderUuid, plainMessage, hasFormattedMessage, formattedMessage, timestamp, salt, hasUnsignedContent, unsignedContent, filterType, type, networkName, hasNetworkTargetName, networkTargetName) + return PlayerChatPacket(senderUuid, headerSignature, plainMessage, hasFormattedMessage, formattedMessage, timestamp, salt, hasUnsignedContent, unsignedContent, filterType, type, networkName, hasNetworkTargetName, networkTargetName) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PlayerChatPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PlayerChatPacket) { output.writeUUID(value.senderUuid) + output.writeVarIntArray(value.headerSignature) { arrayValue, arrayOutput -> arrayOutput.writeUByte(arrayValue) } output.writeString(value.plainMessage) output.writeBoolean(value.hasFormattedMessage) if (value.hasFormattedMessage) output.writeString(value.formattedMessage!!) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerInfoPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerInfoPacket.kt index 874a686..313c7e2 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerInfoPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerInfoPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class PlayerInfoPacket( val action: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PlayerInfoPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PlayerInfoPacket { val action = input.readVarInt() return PlayerInfoPacket(action) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PlayerInfoPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PlayerInfoPacket) { output.writeVarInt(value.action) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerlistHeaderPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerlistHeaderPacket.kt index 1e9d5f1..ab8592e 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerlistHeaderPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PlayerlistHeaderPacket.kt @@ -17,16 +17,15 @@ data class PlayerlistHeaderPacket( val header: String, val footer: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PlayerlistHeaderPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PlayerlistHeaderPacket { val header = input.readString() val footer = input.readString() return PlayerlistHeaderPacket(header, footer) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PlayerlistHeaderPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PlayerlistHeaderPacket) { output.writeString(value.header) output.writeString(value.footer) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PositionPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PositionPacket.kt index 740c959..a3dfed2 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PositionPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/PositionPacket.kt @@ -29,9 +29,8 @@ data class PositionPacket( val teleportId: Int, // varint val dismountVehicle: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PositionPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PositionPacket { val x = input.readDouble() val y = input.readDouble() val z = input.readDouble() @@ -44,7 +43,7 @@ data class PositionPacket( return PositionPacket(x, y, z, yaw, pitch, flags, teleportId, dismountVehicle) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PositionPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PositionPacket) { output.writeDouble(value.x) output.writeDouble(value.y) output.writeDouble(value.z) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RelEntityMovePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RelEntityMovePacket.kt index 0f4aadc..06f0606 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RelEntityMovePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RelEntityMovePacket.kt @@ -23,9 +23,8 @@ data class RelEntityMovePacket( val dZ: Short, val onGround: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): RelEntityMovePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): RelEntityMovePacket { val entityId = input.readVarInt() val dX = input.readShort() val dY = input.readShort() @@ -35,7 +34,7 @@ data class RelEntityMovePacket( return RelEntityMovePacket(entityId, dX, dY, dZ, onGround) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: RelEntityMovePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: RelEntityMovePacket) { output.writeVarInt(value.entityId) output.writeShort(value.dX) output.writeShort(value.dY) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RemoveEntityEffectPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RemoveEntityEffectPacket.kt index 69fdaf8..6f3ea34 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RemoveEntityEffectPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RemoveEntityEffectPacket.kt @@ -17,16 +17,15 @@ data class RemoveEntityEffectPacket( val entityId: Int, // varint val effectId: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): RemoveEntityEffectPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): RemoveEntityEffectPacket { val entityId = input.readVarInt() val effectId = input.readVarInt() return RemoveEntityEffectPacket(entityId, effectId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: RemoveEntityEffectPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: RemoveEntityEffectPacket) { output.writeVarInt(value.entityId) output.writeVarInt(value.effectId) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ResourcePackSendPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ResourcePackSendPacket.kt index bf07812..1cebbbc 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ResourcePackSendPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ResourcePackSendPacket.kt @@ -23,9 +23,8 @@ data class ResourcePackSendPacket( val hasPromptMessage: Boolean, val promptMessage: String?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ResourcePackSendPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ResourcePackSendPacket { val url = input.readString() val hash = input.readString() val forced = input.readBoolean() @@ -35,7 +34,7 @@ data class ResourcePackSendPacket( return ResourcePackSendPacket(url, hash, forced, hasPromptMessage, promptMessage) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ResourcePackSendPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ResourcePackSendPacket) { output.writeString(value.url) output.writeString(value.hash) output.writeBoolean(value.forced) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RespawnPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RespawnPacket.kt index 519b9b3..f27f48d 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RespawnPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/RespawnPacket.kt @@ -3,7 +3,7 @@ package io.layercraft.packetlib.packets.v1_19_2.play.clientbound import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface - +import io.layercraft.packetlib.types.Position /** * Use Item | 0x3e | play | clientbound * @@ -15,6 +15,9 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * @property isDebug isDebug * @property isFlat isFlat * @property copyMetadata copyMetadata + * @property hasDeath death is present + * @property dimensionName dimensionName + * @property location location * @see https://wiki.vg/Protocol#Use_Item */ @@ -28,10 +31,12 @@ data class RespawnPacket( val isDebug: Boolean, val isFlat: Boolean, val copyMetadata: Boolean, + val hasDeath: Boolean, + val dimensionName: String?, + val location: Position?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): RespawnPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): RespawnPacket { val dimension = input.readString() val worldName = input.readString() val hashedSeed = input.readLong() @@ -40,11 +45,14 @@ data class RespawnPacket( val isDebug = input.readBoolean() val isFlat = input.readBoolean() val copyMetadata = input.readBoolean() + val hasDeath = input.readBoolean() + val dimensionName = if (hasDeath) input.readString() else null + val location = if (hasDeath) input.readPosition() else null - return RespawnPacket(dimension, worldName, hashedSeed, gamemode, previousGamemode, isDebug, isFlat, copyMetadata) + return RespawnPacket(dimension, worldName, hashedSeed, gamemode, previousGamemode, isDebug, isFlat, copyMetadata, hasDeath, dimensionName, location) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: RespawnPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: RespawnPacket) { output.writeString(value.dimension) output.writeString(value.worldName) output.writeLong(value.hashedSeed) @@ -53,6 +61,9 @@ data class RespawnPacket( output.writeBoolean(value.isDebug) output.writeBoolean(value.isFlat) output.writeBoolean(value.copyMetadata) + output.writeBoolean(value.hasDeath) + if (value.hasDeath) output.writeString(value.dimensionName!!) + if (value.hasDeath) output.writePosition(value.location!!) } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardDisplayObjectivePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardDisplayObjectivePacket.kt index 65632b8..eea8764 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardDisplayObjectivePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardDisplayObjectivePacket.kt @@ -17,16 +17,15 @@ data class ScoreboardDisplayObjectivePacket( val position: Byte, val name: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ScoreboardDisplayObjectivePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ScoreboardDisplayObjectivePacket { val position = input.readByte() val name = input.readString() return ScoreboardDisplayObjectivePacket(position, name) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ScoreboardDisplayObjectivePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ScoreboardDisplayObjectivePacket) { output.writeByte(value.position) output.writeString(value.name) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardObjectivePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardObjectivePacket.kt index 1cfc874..5b9b106 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardObjectivePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardObjectivePacket.kt @@ -9,6 +9,8 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * * @property name name * @property action action + * @property displayText displayText + * @property type type * @see https://wiki.vg/Protocol#Update_Objectives */ @@ -16,19 +18,40 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class ScoreboardObjectivePacket( val name: String, val action: Byte, + val displayText: String?, + val type: Int?, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ScoreboardObjectivePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ScoreboardObjectivePacket { val name = input.readString() val action = input.readByte() + val displayText = when (action.toInt()) { + 0 -> input.readString() + 2 -> input.readString() + else -> null + } + val type = when (action.toInt()) { + 0 -> input.readVarInt() + 2 -> input.readVarInt() + else -> null + } - return ScoreboardObjectivePacket(name, action) + return ScoreboardObjectivePacket(name, action, displayText, type) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ScoreboardObjectivePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ScoreboardObjectivePacket) { output.writeString(value.name) output.writeByte(value.action) + when (value.action.toInt()) { + 0 -> output.writeString(value.displayText!!) + 2 -> output.writeString(value.displayText!!) + else -> {} + } + when (value.action.toInt()) { + 0 -> output.writeVarInt(value.type!!) + 2 -> output.writeVarInt(value.type!!) + else -> {} + } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardScorePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardScorePacket.kt index 7d8c398..8140c1c 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardScorePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ScoreboardScorePacket.kt @@ -10,6 +10,7 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * @property itemName itemName * @property action action * @property scoreName scoreName + * @property value value * @see https://wiki.vg/Protocol#Update_Score */ @@ -18,21 +19,28 @@ data class ScoreboardScorePacket( val itemName: String, val action: Int, // varint val scoreName: String, + val value: Int?, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ScoreboardScorePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ScoreboardScorePacket { val itemName = input.readString() val action = input.readVarInt() val scoreName = input.readString() + val value = when (action) { + 1 -> null + else -> input.readVarInt() + } - return ScoreboardScorePacket(itemName, action, scoreName) + return ScoreboardScorePacket(itemName, action, scoreName, value) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ScoreboardScorePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ScoreboardScorePacket) { output.writeString(value.itemName) output.writeVarInt(value.action) output.writeString(value.scoreName) + when (value.action) { + else -> output.writeVarInt(value.value!!) + } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SelectAdvancementTabPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SelectAdvancementTabPacket.kt index 517b371..c260eda 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SelectAdvancementTabPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SelectAdvancementTabPacket.kt @@ -17,16 +17,15 @@ data class SelectAdvancementTabPacket( val hasId: Boolean, val id: String?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SelectAdvancementTabPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SelectAdvancementTabPacket { val hasId = input.readBoolean() val id = if (hasId) input.readString() else null return SelectAdvancementTabPacket(hasId, id) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SelectAdvancementTabPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SelectAdvancementTabPacket) { output.writeBoolean(value.hasId) if (value.hasId) output.writeString(value.id!!) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ServerDataPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ServerDataPacket.kt index 591aeec..9b047dd 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ServerDataPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ServerDataPacket.kt @@ -25,9 +25,8 @@ data class ServerDataPacket( val previewsChat: Boolean, val enforcesSecureChat: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ServerDataPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ServerDataPacket { val hasMotd = input.readBoolean() val motd = if (hasMotd) input.readString() else null val hasIcon = input.readBoolean() @@ -38,7 +37,7 @@ data class ServerDataPacket( return ServerDataPacket(hasMotd, motd, hasIcon, icon, previewsChat, enforcesSecureChat) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ServerDataPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ServerDataPacket) { output.writeBoolean(value.hasMotd) if (value.hasMotd) output.writeString(value.motd!!) output.writeBoolean(value.hasIcon) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetCooldownPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetCooldownPacket.kt index 8ad9886..043d80f 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetCooldownPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetCooldownPacket.kt @@ -17,16 +17,15 @@ data class SetCooldownPacket( val itemID: Int, // varint val cooldownTicks: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SetCooldownPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SetCooldownPacket { val itemID = input.readVarInt() val cooldownTicks = input.readVarInt() return SetCooldownPacket(itemID, cooldownTicks) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SetCooldownPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SetCooldownPacket) { output.writeVarInt(value.itemID) output.writeVarInt(value.cooldownTicks) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetPassengersPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetPassengersPacket.kt index 8674b6a..f9faedb 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetPassengersPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetPassengersPacket.kt @@ -8,23 +8,26 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * Set Passengers | 0x57 | play | clientbound * * @property entityId entityId + * @property passengers passengers * @see https://wiki.vg/Protocol#Set_Passengers */ @MinecraftPacket(id = 0x57, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) data class SetPassengersPacket( val entityId: Int, // varint + val passengers: List, // varint array ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SetPassengersPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SetPassengersPacket { val entityId = input.readVarInt() + val passengers = input.readVarIntArray { arrayInput -> arrayInput.readVarInt() } - return SetPassengersPacket(entityId) + return SetPassengersPacket(entityId, passengers) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SetPassengersPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SetPassengersPacket) { output.writeVarInt(value.entityId) + output.writeVarIntArray(value.passengers) { arrayValue, arrayOutput -> arrayOutput.writeVarInt(arrayValue) } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetSlotPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetSlotPacket.kt index 498499e..4372834 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetSlotPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetSlotPacket.kt @@ -19,9 +19,8 @@ data class SetSlotPacket( val stateId: Int, // varint val slot: Short, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SetSlotPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SetSlotPacket { val windowId = input.readByte() val stateId = input.readVarInt() val slot = input.readShort() @@ -29,7 +28,7 @@ data class SetSlotPacket( return SetSlotPacket(windowId, stateId, slot) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SetSlotPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SetSlotPacket) { output.writeByte(value.windowId) output.writeVarInt(value.stateId) output.writeShort(value.slot) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleSubtitlePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleSubtitlePacket.kt index 926e670..0ff23c7 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleSubtitlePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleSubtitlePacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class SetTitleSubtitlePacket( val text: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SetTitleSubtitlePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SetTitleSubtitlePacket { val text = input.readString() return SetTitleSubtitlePacket(text) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SetTitleSubtitlePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SetTitleSubtitlePacket) { output.writeString(value.text) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleTextPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleTextPacket.kt index 359e7fb..ae72d73 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleTextPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleTextPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class SetTitleTextPacket( val text: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SetTitleTextPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SetTitleTextPacket { val text = input.readString() return SetTitleTextPacket(text) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SetTitleTextPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SetTitleTextPacket) { output.writeString(value.text) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleTimePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleTimePacket.kt index e52a581..c3628c3 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleTimePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SetTitleTimePacket.kt @@ -19,9 +19,8 @@ data class SetTitleTimePacket( val stay: Int, val fadeOut: Int, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SetTitleTimePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SetTitleTimePacket { val fadeIn = input.readInt() val stay = input.readInt() val fadeOut = input.readInt() @@ -29,7 +28,7 @@ data class SetTitleTimePacket( return SetTitleTimePacket(fadeIn, stay, fadeOut) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SetTitleTimePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SetTitleTimePacket) { output.writeInt(value.fadeIn) output.writeInt(value.stay) output.writeInt(value.fadeOut) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ShouldDisplayChatPreviewPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ShouldDisplayChatPreviewPacket.kt index 26c0754..ee13991 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ShouldDisplayChatPreviewPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/ShouldDisplayChatPreviewPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class ShouldDisplayChatPreviewPacket( val shouldDisplayChatPreview: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ShouldDisplayChatPreviewPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ShouldDisplayChatPreviewPacket { val shouldDisplayChatPreview = input.readBoolean() return ShouldDisplayChatPreviewPacket(shouldDisplayChatPreview) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ShouldDisplayChatPreviewPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ShouldDisplayChatPreviewPacket) { output.writeBoolean(value.shouldDisplayChatPreview) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SimulationDistancePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SimulationDistancePacket.kt index 6e31ae2..ce04d1c 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SimulationDistancePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SimulationDistancePacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class SimulationDistancePacket( val distance: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SimulationDistancePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SimulationDistancePacket { val distance = input.readVarInt() return SimulationDistancePacket(distance) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SimulationDistancePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SimulationDistancePacket) { output.writeVarInt(value.distance) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SoundEffectPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SoundEffectPacket.kt index 8bcf451..7a86dfd 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SoundEffectPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SoundEffectPacket.kt @@ -29,9 +29,8 @@ data class SoundEffectPacket( val pitch: Float, val seed: Long, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SoundEffectPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SoundEffectPacket { val soundId = input.readVarInt() val soundCategory = input.readVarInt() val x = input.readInt() @@ -44,7 +43,7 @@ data class SoundEffectPacket( return SoundEffectPacket(soundId, soundCategory, x, y, z, volume, pitch, seed) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SoundEffectPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SoundEffectPacket) { output.writeVarInt(value.soundId) output.writeVarInt(value.soundCategory) output.writeInt(value.x) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnEntityExperienceOrbPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnEntityExperienceOrbPacket.kt index 9b49872..b692bfc 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnEntityExperienceOrbPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnEntityExperienceOrbPacket.kt @@ -23,9 +23,8 @@ data class SpawnEntityExperienceOrbPacket( val z: Double, val count: Short, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SpawnEntityExperienceOrbPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SpawnEntityExperienceOrbPacket { val entityId = input.readVarInt() val x = input.readDouble() val y = input.readDouble() @@ -35,7 +34,7 @@ data class SpawnEntityExperienceOrbPacket( return SpawnEntityExperienceOrbPacket(entityId, x, y, z, count) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SpawnEntityExperienceOrbPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SpawnEntityExperienceOrbPacket) { output.writeVarInt(value.entityId) output.writeDouble(value.x) output.writeDouble(value.y) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnEntityPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnEntityPacket.kt index 77b052e..92906ee 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnEntityPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnEntityPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import java.util.UUID - /** * Spawn Entity | 0x00 | play | clientbound * @@ -40,9 +39,8 @@ data class SpawnEntityPacket( val velocityY: Short, val velocityZ: Short, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SpawnEntityPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SpawnEntityPacket { val entityId = input.readVarInt() val objectUUID = input.readUUID() val type = input.readVarInt() @@ -60,7 +58,7 @@ data class SpawnEntityPacket( return SpawnEntityPacket(entityId, objectUUID, type, x, y, z, pitch, yaw, headPitch, objectData, velocityX, velocityY, velocityZ) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SpawnEntityPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SpawnEntityPacket) { output.writeVarInt(value.entityId) output.writeUUID(value.objectUUID) output.writeVarInt(value.type) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnPositionPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnPositionPacket.kt index 6072140..3154e04 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnPositionPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SpawnPositionPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Use Item | 0x4d | play | clientbound * @@ -18,16 +17,15 @@ data class SpawnPositionPacket( val location: Position, val angle: Float, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SpawnPositionPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SpawnPositionPacket { val location = input.readPosition() val angle = input.readFloat() return SpawnPositionPacket(location, angle) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SpawnPositionPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SpawnPositionPacket) { output.writePosition(value.location) output.writeFloat(value.angle) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/StatisticsPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/StatisticsPacket.kt index 1a1d907..ae10e22 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/StatisticsPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/StatisticsPacket.kt @@ -13,13 +13,12 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface @MinecraftPacket(id = 0x04, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) class StatisticsPacket() : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): StatisticsPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): StatisticsPacket { return StatisticsPacket() } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: StatisticsPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: StatisticsPacket) { } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/StopSoundPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/StopSoundPacket.kt index cd79fa5..6cea61d 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/StopSoundPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/StopSoundPacket.kt @@ -8,23 +8,46 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * Stop Sound | 0x61 | play | clientbound * * @property flags flags + * @property source source + * @property sound sound * @see https://wiki.vg/Protocol#Stop_Sound */ @MinecraftPacket(id = 0x61, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) data class StopSoundPacket( val flags: Byte, + val source: Int?, // varint + val sound: String?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): StopSoundPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): StopSoundPacket { val flags = input.readByte() + val source = when (flags.toInt()) { + 3 -> input.readVarInt() + 1 -> input.readVarInt() + else -> null + } + val sound = when (flags.toInt()) { + 3 -> input.readString() + 2 -> input.readString() + else -> null + } - return StopSoundPacket(flags) + return StopSoundPacket(flags, source, sound) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: StopSoundPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: StopSoundPacket) { output.writeByte(value.flags) + when (value.flags.toInt()) { + 3 -> output.writeVarInt(value.source!!) + 1 -> output.writeVarInt(value.source!!) + else -> {} + } + when (value.flags.toInt()) { + 3 -> output.writeString(value.sound!!) + 2 -> output.writeString(value.sound!!) + else -> {} + } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SystemChatPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SystemChatPacket.kt index 39b9aaa..0efb257 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SystemChatPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/SystemChatPacket.kt @@ -17,16 +17,15 @@ data class SystemChatPacket( val content: String, val isActionBar: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SystemChatPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SystemChatPacket { val content = input.readString() val isActionBar = input.readBoolean() return SystemChatPacket(content, isActionBar) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SystemChatPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SystemChatPacket) { output.writeString(value.content) output.writeBoolean(value.isActionBar) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TabCompletePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TabCompletePacket.kt index 136b749..0d1c973 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TabCompletePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TabCompletePacket.kt @@ -19,9 +19,8 @@ data class TabCompletePacket( val start: Int, // varint val length: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): TabCompletePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): TabCompletePacket { val transactionId = input.readVarInt() val start = input.readVarInt() val length = input.readVarInt() @@ -29,7 +28,7 @@ data class TabCompletePacket( return TabCompletePacket(transactionId, start, length) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: TabCompletePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: TabCompletePacket) { output.writeVarInt(value.transactionId) output.writeVarInt(value.start) output.writeVarInt(value.length) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TagsPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TagsPacket.kt index cb61a3b..ac080c7 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TagsPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TagsPacket.kt @@ -13,13 +13,12 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface @MinecraftPacket(id = 0x6b, state = PacketState.PLAY, direction = PacketDirection.CLIENTBOUND) class TagsPacket() : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): TagsPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): TagsPacket { return TagsPacket() } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: TagsPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: TagsPacket) { } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TeamsPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TeamsPacket.kt index cd6e7af..08ba193 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TeamsPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TeamsPacket.kt @@ -9,6 +9,13 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * * @property team team * @property mode mode + * @property name name + * @property friendlyFire friendlyFire + * @property nameTagVisibility nameTagVisibility + * @property collisionRule collisionRule + * @property formatting formatting + * @property prefix prefix + * @property suffix suffix * @see https://wiki.vg/Protocol#Update_Teams */ @@ -16,19 +23,95 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class TeamsPacket( val team: String, val mode: Byte, + val name: String?, + val friendlyFire: Byte?, + val nameTagVisibility: String?, + val collisionRule: String?, + val formatting: Int?, // varint + val prefix: String?, + val suffix: String?, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): TeamsPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): TeamsPacket { val team = input.readString() val mode = input.readByte() + val name = when (mode.toInt()) { + 0 -> input.readString() + 2 -> input.readString() + else -> null + } + val friendlyFire = when (mode.toInt()) { + 0 -> input.readByte() + 2 -> input.readByte() + else -> null + } + val nameTagVisibility = when (mode.toInt()) { + 0 -> input.readString() + 2 -> input.readString() + else -> null + } + val collisionRule = when (mode.toInt()) { + 0 -> input.readString() + 2 -> input.readString() + else -> null + } + val formatting = when (mode.toInt()) { + 0 -> input.readVarInt() + 2 -> input.readVarInt() + else -> null + } + val prefix = when (mode.toInt()) { + 0 -> input.readString() + 2 -> input.readString() + else -> null + } + val suffix = when (mode.toInt()) { + 0 -> input.readString() + 2 -> input.readString() + else -> null + } - return TeamsPacket(team, mode) + return TeamsPacket(team, mode, name, friendlyFire, nameTagVisibility, collisionRule, formatting, prefix, suffix) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: TeamsPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: TeamsPacket) { output.writeString(value.team) output.writeByte(value.mode) + when (value.mode.toInt()) { + 0 -> output.writeString(value.name!!) + 2 -> output.writeString(value.name!!) + else -> {} + } + when (value.mode.toInt()) { + 0 -> output.writeByte(value.friendlyFire!!) + 2 -> output.writeByte(value.friendlyFire!!) + else -> {} + } + when (value.mode.toInt()) { + 0 -> output.writeString(value.nameTagVisibility!!) + 2 -> output.writeString(value.nameTagVisibility!!) + else -> {} + } + when (value.mode.toInt()) { + 0 -> output.writeString(value.collisionRule!!) + 2 -> output.writeString(value.collisionRule!!) + else -> {} + } + when (value.mode.toInt()) { + 0 -> output.writeVarInt(value.formatting!!) + 2 -> output.writeVarInt(value.formatting!!) + else -> {} + } + when (value.mode.toInt()) { + 0 -> output.writeString(value.prefix!!) + 2 -> output.writeString(value.prefix!!) + else -> {} + } + when (value.mode.toInt()) { + 0 -> output.writeString(value.suffix!!) + 2 -> output.writeString(value.suffix!!) + else -> {} + } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TileEntityDataPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TileEntityDataPacket.kt index d6de92b..27cb629 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TileEntityDataPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TileEntityDataPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Block Entity Data | 0x07 | play | clientbound * @@ -20,9 +19,8 @@ data class TileEntityDataPacket( val action: Int, // varint val nbtData: ByteArray, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): TileEntityDataPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): TileEntityDataPacket { val location = input.readPosition() val action = input.readVarInt() val nbtData = input.readNBT() @@ -30,7 +28,7 @@ data class TileEntityDataPacket( return TileEntityDataPacket(location, action, nbtData) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: TileEntityDataPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: TileEntityDataPacket) { output.writePosition(value.location) output.writeVarInt(value.action) output.writeBytes(value.nbtData) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TradeListPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TradeListPacket.kt index e5cddff..a2317fb 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TradeListPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/TradeListPacket.kt @@ -23,9 +23,8 @@ data class TradeListPacket( val isRegularVillager: Boolean, val canRestock: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): TradeListPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): TradeListPacket { val windowId = input.readVarInt() val villagerLevel = input.readVarInt() val experience = input.readVarInt() @@ -35,7 +34,7 @@ data class TradeListPacket( return TradeListPacket(windowId, villagerLevel, experience, isRegularVillager, canRestock) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: TradeListPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: TradeListPacket) { output.writeVarInt(value.windowId) output.writeVarInt(value.villagerLevel) output.writeVarInt(value.experience) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UnloadChunkPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UnloadChunkPacket.kt index 1a75553..efee9eb 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UnloadChunkPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UnloadChunkPacket.kt @@ -17,16 +17,15 @@ data class UnloadChunkPacket( val chunkX: Int, val chunkZ: Int, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UnloadChunkPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UnloadChunkPacket { val chunkX = input.readInt() val chunkZ = input.readInt() return UnloadChunkPacket(chunkX, chunkZ) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UnloadChunkPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UnloadChunkPacket) { output.writeInt(value.chunkX) output.writeInt(value.chunkZ) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UnlockRecipesPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UnlockRecipesPacket.kt index c6e2877..7c1091a 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UnlockRecipesPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UnlockRecipesPacket.kt @@ -16,6 +16,7 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * @property filteringBlastFurnace filteringBlastFurnace * @property smokerBookOpen smokerBookOpen * @property filteringSmoker filteringSmoker + * @property recipes1 recipes1 * @see https://wiki.vg/Protocol#Use_Item */ @@ -30,10 +31,10 @@ data class UnlockRecipesPacket( val filteringBlastFurnace: Boolean, val smokerBookOpen: Boolean, val filteringSmoker: Boolean, + val recipes1: List, // varint array ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UnlockRecipesPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UnlockRecipesPacket { val action = input.readVarInt() val craftingBookOpen = input.readBoolean() val filteringCraftable = input.readBoolean() @@ -43,11 +44,12 @@ data class UnlockRecipesPacket( val filteringBlastFurnace = input.readBoolean() val smokerBookOpen = input.readBoolean() val filteringSmoker = input.readBoolean() + val recipes1 = input.readVarIntArray { arrayInput -> arrayInput.readString() } - return UnlockRecipesPacket(action, craftingBookOpen, filteringCraftable, smeltingBookOpen, filteringSmeltable, blastFurnaceOpen, filteringBlastFurnace, smokerBookOpen, filteringSmoker) + return UnlockRecipesPacket(action, craftingBookOpen, filteringCraftable, smeltingBookOpen, filteringSmeltable, blastFurnaceOpen, filteringBlastFurnace, smokerBookOpen, filteringSmoker, recipes1) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UnlockRecipesPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UnlockRecipesPacket) { output.writeVarInt(value.action) output.writeBoolean(value.craftingBookOpen) output.writeBoolean(value.filteringCraftable) @@ -57,6 +59,7 @@ data class UnlockRecipesPacket( output.writeBoolean(value.filteringBlastFurnace) output.writeBoolean(value.smokerBookOpen) output.writeBoolean(value.filteringSmoker) + output.writeVarIntArray(value.recipes1) { arrayValue, arrayOutput -> arrayOutput.writeString(arrayValue) } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateHealthPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateHealthPacket.kt index 399c350..44ae727 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateHealthPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateHealthPacket.kt @@ -19,9 +19,8 @@ data class UpdateHealthPacket( val food: Int, // varint val foodSaturation: Float, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateHealthPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateHealthPacket { val health = input.readFloat() val food = input.readVarInt() val foodSaturation = input.readFloat() @@ -29,7 +28,7 @@ data class UpdateHealthPacket( return UpdateHealthPacket(health, food, foodSaturation) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateHealthPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateHealthPacket) { output.writeFloat(value.health) output.writeVarInt(value.food) output.writeFloat(value.foodSaturation) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateLightPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateLightPacket.kt index 3bfef2f..bf8d55c 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateLightPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateLightPacket.kt @@ -10,6 +10,10 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * @property chunkX chunkX * @property chunkZ chunkZ * @property trustEdges trustEdges + * @property skyLightMask skyLightMask + * @property blockLightMask blockLightMask + * @property emptySkyLightMask emptySkyLightMask + * @property emptyBlockLightMask emptyBlockLightMask * @see https://wiki.vg/Protocol#Update_Light */ @@ -18,21 +22,32 @@ data class UpdateLightPacket( val chunkX: Int, // varint val chunkZ: Int, // varint val trustEdges: Boolean, + val skyLightMask: List, // varint array + val blockLightMask: List, // varint array + val emptySkyLightMask: List, // varint array + val emptyBlockLightMask: List, // varint array ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateLightPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateLightPacket { val chunkX = input.readVarInt() val chunkZ = input.readVarInt() val trustEdges = input.readBoolean() + val skyLightMask = input.readVarIntArray { arrayInput -> arrayInput.readLong() } + val blockLightMask = input.readVarIntArray { arrayInput -> arrayInput.readLong() } + val emptySkyLightMask = input.readVarIntArray { arrayInput -> arrayInput.readLong() } + val emptyBlockLightMask = input.readVarIntArray { arrayInput -> arrayInput.readLong() } - return UpdateLightPacket(chunkX, chunkZ, trustEdges) + return UpdateLightPacket(chunkX, chunkZ, trustEdges, skyLightMask, blockLightMask, emptySkyLightMask, emptyBlockLightMask) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateLightPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateLightPacket) { output.writeVarInt(value.chunkX) output.writeVarInt(value.chunkZ) output.writeBoolean(value.trustEdges) + output.writeVarIntArray(value.skyLightMask) { arrayValue, arrayOutput -> arrayOutput.writeLong(arrayValue) } + output.writeVarIntArray(value.blockLightMask) { arrayValue, arrayOutput -> arrayOutput.writeLong(arrayValue) } + output.writeVarIntArray(value.emptySkyLightMask) { arrayValue, arrayOutput -> arrayOutput.writeLong(arrayValue) } + output.writeVarIntArray(value.emptyBlockLightMask) { arrayValue, arrayOutput -> arrayOutput.writeLong(arrayValue) } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateTimePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateTimePacket.kt index a33b378..eea8fa9 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateTimePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateTimePacket.kt @@ -17,16 +17,15 @@ data class UpdateTimePacket( val age: Long, val time: Long, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateTimePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateTimePacket { val age = input.readLong() val time = input.readLong() return UpdateTimePacket(age, time) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateTimePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateTimePacket) { output.writeLong(value.age) output.writeLong(value.time) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateViewDistancePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateViewDistancePacket.kt index 617c0fe..7de59ff 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateViewDistancePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateViewDistancePacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class UpdateViewDistancePacket( val viewDistance: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateViewDistancePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateViewDistancePacket { val viewDistance = input.readVarInt() return UpdateViewDistancePacket(viewDistance) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateViewDistancePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateViewDistancePacket) { output.writeVarInt(value.viewDistance) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateViewPositionPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateViewPositionPacket.kt index 4e11b6c..ff0cb13 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateViewPositionPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/UpdateViewPositionPacket.kt @@ -17,16 +17,15 @@ data class UpdateViewPositionPacket( val chunkX: Int, // varint val chunkZ: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateViewPositionPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateViewPositionPacket { val chunkX = input.readVarInt() val chunkZ = input.readVarInt() return UpdateViewPositionPacket(chunkX, chunkZ) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateViewPositionPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateViewPositionPacket) { output.writeVarInt(value.chunkX) output.writeVarInt(value.chunkZ) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/VehicleMovePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/VehicleMovePacket.kt index baaa6c8..f6b7d71 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/VehicleMovePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/VehicleMovePacket.kt @@ -23,9 +23,8 @@ data class VehicleMovePacket( val yaw: Float, val pitch: Float, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): VehicleMovePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): VehicleMovePacket { val x = input.readDouble() val y = input.readDouble() val z = input.readDouble() @@ -35,7 +34,7 @@ data class VehicleMovePacket( return VehicleMovePacket(x, y, z, yaw, pitch) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: VehicleMovePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: VehicleMovePacket) { output.writeDouble(value.x) output.writeDouble(value.y) output.writeDouble(value.z) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WindowItemsPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WindowItemsPacket.kt index 3153d66..41cdb7a 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WindowItemsPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WindowItemsPacket.kt @@ -17,16 +17,15 @@ data class WindowItemsPacket( val windowId: UByte, val stateId: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): WindowItemsPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): WindowItemsPacket { val windowId = input.readUByte() val stateId = input.readVarInt() return WindowItemsPacket(windowId, stateId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: WindowItemsPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: WindowItemsPacket) { output.writeUByte(value.windowId) output.writeVarInt(value.stateId) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderCenterPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderCenterPacket.kt index 30a9f9c..e7abd82 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderCenterPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderCenterPacket.kt @@ -17,16 +17,15 @@ data class WorldBorderCenterPacket( val x: Double, val z: Double, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): WorldBorderCenterPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): WorldBorderCenterPacket { val x = input.readDouble() val z = input.readDouble() return WorldBorderCenterPacket(x, z) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldBorderCenterPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldBorderCenterPacket) { output.writeDouble(value.x) output.writeDouble(value.z) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderLerpSizePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderLerpSizePacket.kt index 0e76aa1..0e32161 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderLerpSizePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderLerpSizePacket.kt @@ -19,9 +19,8 @@ data class WorldBorderLerpSizePacket( val newDiameter: Double, val speed: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): WorldBorderLerpSizePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): WorldBorderLerpSizePacket { val oldDiameter = input.readDouble() val newDiameter = input.readDouble() val speed = input.readVarInt() @@ -29,7 +28,7 @@ data class WorldBorderLerpSizePacket( return WorldBorderLerpSizePacket(oldDiameter, newDiameter, speed) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldBorderLerpSizePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldBorderLerpSizePacket) { output.writeDouble(value.oldDiameter) output.writeDouble(value.newDiameter) output.writeVarInt(value.speed) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderSizePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderSizePacket.kt index 99b4563..5b0122c 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderSizePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderSizePacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class WorldBorderSizePacket( val diameter: Double, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): WorldBorderSizePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): WorldBorderSizePacket { val diameter = input.readDouble() return WorldBorderSizePacket(diameter) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldBorderSizePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldBorderSizePacket) { output.writeDouble(value.diameter) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderWarningDelayPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderWarningDelayPacket.kt index 22577a7..9a4f27b 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderWarningDelayPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderWarningDelayPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class WorldBorderWarningDelayPacket( val warningTime: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): WorldBorderWarningDelayPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): WorldBorderWarningDelayPacket { val warningTime = input.readVarInt() return WorldBorderWarningDelayPacket(warningTime) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldBorderWarningDelayPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldBorderWarningDelayPacket) { output.writeVarInt(value.warningTime) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderWarningReachPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderWarningReachPacket.kt index 563d859..dd0f99d 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderWarningReachPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldBorderWarningReachPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class WorldBorderWarningReachPacket( val warningBlocks: Int, // varint ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): WorldBorderWarningReachPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): WorldBorderWarningReachPacket { val warningBlocks = input.readVarInt() return WorldBorderWarningReachPacket(warningBlocks) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldBorderWarningReachPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldBorderWarningReachPacket) { output.writeVarInt(value.warningBlocks) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldEventPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldEventPacket.kt index 057ea7b..4da609e 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldEventPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldEventPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * World Event | 0x22 | play | clientbound * @@ -22,9 +21,8 @@ data class WorldEventPacket( val data: Int, val global: Boolean, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): WorldEventPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): WorldEventPacket { val effectId = input.readInt() val location = input.readPosition() val data = input.readInt() @@ -33,7 +31,7 @@ data class WorldEventPacket( return WorldEventPacket(effectId, location, data, global) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldEventPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldEventPacket) { output.writeInt(value.effectId) output.writePosition(value.location) output.writeInt(value.data) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldParticlesPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldParticlesPacket.kt index 977389f..112d3eb 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldParticlesPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/clientbound/WorldParticlesPacket.kt @@ -33,9 +33,8 @@ data class WorldParticlesPacket( val particleData: Float, val particles: Int, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): WorldParticlesPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): WorldParticlesPacket { val particleId = input.readVarInt() val longDistance = input.readBoolean() val x = input.readDouble() @@ -50,7 +49,7 @@ data class WorldParticlesPacket( return WorldParticlesPacket(particleId, longDistance, x, y, z, offsetX, offsetY, offsetZ, particleData, particles) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldParticlesPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: WorldParticlesPacket) { output.writeVarInt(value.particleId) output.writeBoolean(value.longDistance) output.writeDouble(value.x) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/AbilitiesPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/AbilitiesPacket.kt index cdecbdb..d218cb9 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/AbilitiesPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/AbilitiesPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class AbilitiesPacket( val flags: Byte, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): AbilitiesPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): AbilitiesPacket { val flags = input.readByte() return AbilitiesPacket(flags) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: AbilitiesPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: AbilitiesPacket) { output.writeByte(value.flags) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/AdvancementTabPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/AdvancementTabPacket.kt index bb6f14a..304197d 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/AdvancementTabPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/AdvancementTabPacket.kt @@ -8,23 +8,33 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * Seen Advancements | 0x25 | play | serverbound * * @property action action + * @property tabId tabId * @see https://wiki.vg/Protocol#Seen_Advancements */ @MinecraftPacket(id = 0x25, state = PacketState.PLAY, direction = PacketDirection.SERVERBOUND) data class AdvancementTabPacket( val action: Int, // varint + val tabId: String?, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): AdvancementTabPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): AdvancementTabPacket { val action = input.readVarInt() + val tabId = when (action) { + 0 -> input.readString() + 1 -> null + else -> null + } - return AdvancementTabPacket(action) + return AdvancementTabPacket(action, tabId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: AdvancementTabPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: AdvancementTabPacket) { output.writeVarInt(value.action) + when (value.action) { + 0 -> output.writeString(value.tabId!!) + else -> {} + } } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ArmAnimationPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ArmAnimationPacket.kt index 67306a2..852af25 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ArmAnimationPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ArmAnimationPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class ArmAnimationPacket( val hand: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ArmAnimationPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ArmAnimationPacket { val hand = input.readVarInt() return ArmAnimationPacket(hand) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ArmAnimationPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ArmAnimationPacket) { output.writeVarInt(value.hand) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/BlockDigPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/BlockDigPacket.kt index 7c29c6e..a025ab1 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/BlockDigPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/BlockDigPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Use Item | 0x1d | play | serverbound * @@ -22,9 +21,8 @@ data class BlockDigPacket( val face: Byte, val sequence: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): BlockDigPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): BlockDigPacket { val status = input.readVarInt() val location = input.readPosition() val face = input.readByte() @@ -33,7 +31,7 @@ data class BlockDigPacket( return BlockDigPacket(status, location, face, sequence) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: BlockDigPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: BlockDigPacket) { output.writeVarInt(value.status) output.writePosition(value.location) output.writeByte(value.face) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/BlockPlacePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/BlockPlacePacket.kt index b8d01fe..6168112 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/BlockPlacePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/BlockPlacePacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Use Item On | 0x31 | play | serverbound * @@ -30,9 +29,8 @@ data class BlockPlacePacket( val insideBlock: Boolean, val sequence: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): BlockPlacePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): BlockPlacePacket { val hand = input.readVarInt() val location = input.readPosition() val direction = input.readVarInt() @@ -45,7 +43,7 @@ data class BlockPlacePacket( return BlockPlacePacket(hand, location, direction, cursorX, cursorY, cursorZ, insideBlock, sequence) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: BlockPlacePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: BlockPlacePacket) { output.writeVarInt(value.hand) output.writePosition(value.location) output.writeVarInt(value.direction) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatCommandPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatCommandPacket.kt index 5a15a4d..f5d8581 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatCommandPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatCommandPacket.kt @@ -3,7 +3,7 @@ package io.layercraft.packetlib.packets.v1_19_2.play.serverbound import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface - +import java.util.UUID /** * Chat Command | 0x04 | play | serverbound * @@ -11,6 +11,8 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * @property timestamp timestamp * @property salt salt * @property signedPreview signedPreview + * @property hasLastMessage lastMessage is present + * @property sender sender * @see https://wiki.vg/Protocol#Chat_Command */ @@ -20,23 +22,28 @@ data class ChatCommandPacket( val timestamp: Long, val salt: Long, val signedPreview: Boolean, + val hasLastMessage: Boolean, + val sender: UUID?, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ChatCommandPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ChatCommandPacket { val command = input.readString() val timestamp = input.readLong() val salt = input.readLong() val signedPreview = input.readBoolean() + val hasLastMessage = input.readBoolean() + val sender = if (hasLastMessage) input.readUUID() else null - return ChatCommandPacket(command, timestamp, salt, signedPreview) + return ChatCommandPacket(command, timestamp, salt, signedPreview, hasLastMessage, sender) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ChatCommandPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ChatCommandPacket) { output.writeString(value.command) output.writeLong(value.timestamp) output.writeLong(value.salt) output.writeBoolean(value.signedPreview) + output.writeBoolean(value.hasLastMessage) + if (value.hasLastMessage) output.writeUUID(value.sender!!) } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatMessagePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatMessagePacket.kt index 0a01e82..026a1cb 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatMessagePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatMessagePacket.kt @@ -3,14 +3,17 @@ package io.layercraft.packetlib.packets.v1_19_2.play.serverbound import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface - +import java.util.UUID /** * Chat Message | 0x05 | play | serverbound * * @property message message * @property timestamp timestamp * @property salt salt + * @property signature signature * @property signedPreview signedPreview + * @property hasLastMessage lastMessage is present + * @property lastMessageUser lastMessageUser * @see https://wiki.vg/Protocol#Chat_Message */ @@ -19,24 +22,32 @@ data class ChatMessagePacket( val message: String, val timestamp: Long, val salt: Long, + val signature: ByteArray, val signedPreview: Boolean, + val hasLastMessage: Boolean, + val lastMessageUser: UUID?, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ChatMessagePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ChatMessagePacket { val message = input.readString() val timestamp = input.readLong() val salt = input.readLong() + val signature = input.readVarIntByteArray() val signedPreview = input.readBoolean() + val hasLastMessage = input.readBoolean() + val lastMessageUser = if (hasLastMessage) input.readUUID() else null - return ChatMessagePacket(message, timestamp, salt, signedPreview) + return ChatMessagePacket(message, timestamp, salt, signature, signedPreview, hasLastMessage, lastMessageUser) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ChatMessagePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ChatMessagePacket) { output.writeString(value.message) output.writeLong(value.timestamp) output.writeLong(value.salt) + output.writeVarIntByteArray(value.signature) output.writeBoolean(value.signedPreview) + output.writeBoolean(value.hasLastMessage) + if (value.hasLastMessage) output.writeUUID(value.lastMessageUser!!) } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatPreviewPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatPreviewPacket.kt index 6fde5d3..d4284c7 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatPreviewPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ChatPreviewPacket.kt @@ -17,16 +17,15 @@ data class ChatPreviewPacket( val query: Int, val message: String, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ChatPreviewPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ChatPreviewPacket { val query = input.readInt() val message = input.readString() return ChatPreviewPacket(query, message) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ChatPreviewPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ChatPreviewPacket) { output.writeInt(value.query) output.writeString(value.message) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ClientCommandPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ClientCommandPacket.kt index a1e7603..953935c 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ClientCommandPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ClientCommandPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class ClientCommandPacket( val actionId: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ClientCommandPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ClientCommandPacket { val actionId = input.readVarInt() return ClientCommandPacket(actionId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ClientCommandPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ClientCommandPacket) { output.writeVarInt(value.actionId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CloseWindowPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CloseWindowPacket.kt index 05159ec..4cd6590 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CloseWindowPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CloseWindowPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class CloseWindowPacket( val windowId: UByte, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): CloseWindowPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): CloseWindowPacket { val windowId = input.readUByte() return CloseWindowPacket(windowId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: CloseWindowPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: CloseWindowPacket) { output.writeUByte(value.windowId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CraftRecipeRequestPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CraftRecipeRequestPacket.kt index e6ce6ce..a59bac7 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CraftRecipeRequestPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CraftRecipeRequestPacket.kt @@ -19,9 +19,8 @@ data class CraftRecipeRequestPacket( val recipe: String, val makeAll: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): CraftRecipeRequestPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): CraftRecipeRequestPacket { val windowId = input.readByte() val recipe = input.readString() val makeAll = input.readBoolean() @@ -29,7 +28,7 @@ data class CraftRecipeRequestPacket( return CraftRecipeRequestPacket(windowId, recipe, makeAll) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: CraftRecipeRequestPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: CraftRecipeRequestPacket) { output.writeByte(value.windowId) output.writeString(value.recipe) output.writeBoolean(value.makeAll) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CustomPayloadPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CustomPayloadPacket.kt index 998c8d5..8c454d8 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CustomPayloadPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/CustomPayloadPacket.kt @@ -17,16 +17,15 @@ data class CustomPayloadPacket( val channel: String, val data: ByteArray, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): CustomPayloadPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): CustomPayloadPacket { val channel = input.readString() val data = input.readRemainingByteArray() return CustomPayloadPacket(channel, data) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: CustomPayloadPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: CustomPayloadPacket) { output.writeString(value.channel) output.writeRemainingByteArray(value.data) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/DisplayedRecipePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/DisplayedRecipePacket.kt index fb9fd5c..c4127f6 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/DisplayedRecipePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/DisplayedRecipePacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class DisplayedRecipePacket( val recipeId: String, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): DisplayedRecipePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): DisplayedRecipePacket { val recipeId = input.readString() return DisplayedRecipePacket(recipeId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: DisplayedRecipePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: DisplayedRecipePacket) { output.writeString(value.recipeId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EditBookPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EditBookPacket.kt index bedd7d3..8180382 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EditBookPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EditBookPacket.kt @@ -8,6 +8,7 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * Use Item | 0x0e | play | serverbound * * @property hand hand + * @property pages pages * @property hasTitle title is present * @property title title * @see https://wiki.vg/Protocol#Use_Item @@ -16,21 +17,23 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface @MinecraftPacket(id = 0x0e, state = PacketState.PLAY, direction = PacketDirection.SERVERBOUND) data class EditBookPacket( val hand: Int, // varint + val pages: List, // varint array val hasTitle: Boolean, val title: String?, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EditBookPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EditBookPacket { val hand = input.readVarInt() + val pages = input.readVarIntArray { arrayInput -> arrayInput.readString() } val hasTitle = input.readBoolean() val title = if (hasTitle) input.readString() else null - return EditBookPacket(hand, hasTitle, title) + return EditBookPacket(hand, pages, hasTitle, title) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EditBookPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EditBookPacket) { output.writeVarInt(value.hand) + output.writeVarIntArray(value.pages) { arrayValue, arrayOutput -> arrayOutput.writeString(arrayValue) } output.writeBoolean(value.hasTitle) if (value.hasTitle) output.writeString(value.title!!) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EnchantItemPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EnchantItemPacket.kt index 9e5a2d7..8c2e503 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EnchantItemPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EnchantItemPacket.kt @@ -17,16 +17,15 @@ data class EnchantItemPacket( val windowId: Byte, val enchantment: Byte, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EnchantItemPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EnchantItemPacket { val windowId = input.readByte() val enchantment = input.readByte() return EnchantItemPacket(windowId, enchantment) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EnchantItemPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EnchantItemPacket) { output.writeByte(value.windowId) output.writeByte(value.enchantment) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EntityActionPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EntityActionPacket.kt index 991643e..a29e5a0 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EntityActionPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/EntityActionPacket.kt @@ -19,9 +19,8 @@ data class EntityActionPacket( val actionId: Int, // varint val jumpBoost: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): EntityActionPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): EntityActionPacket { val entityId = input.readVarInt() val actionId = input.readVarInt() val jumpBoost = input.readVarInt() @@ -29,7 +28,7 @@ data class EntityActionPacket( return EntityActionPacket(entityId, actionId, jumpBoost) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityActionPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: EntityActionPacket) { output.writeVarInt(value.entityId) output.writeVarInt(value.actionId) output.writeVarInt(value.jumpBoost) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/FlyingPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/FlyingPacket.kt index 00a4d93..f40c6b2 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/FlyingPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/FlyingPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class FlyingPacket( val onGround: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): FlyingPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): FlyingPacket { val onGround = input.readBoolean() return FlyingPacket(onGround) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: FlyingPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: FlyingPacket) { output.writeBoolean(value.onGround) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/GenerateStructurePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/GenerateStructurePacket.kt index 4d9ef19..724ccc4 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/GenerateStructurePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/GenerateStructurePacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Jigsaw Generate | 0x11 | play | serverbound * @@ -20,9 +19,8 @@ data class GenerateStructurePacket( val levels: Int, // varint val keepJigsaws: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): GenerateStructurePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): GenerateStructurePacket { val location = input.readPosition() val levels = input.readVarInt() val keepJigsaws = input.readBoolean() @@ -30,7 +28,7 @@ data class GenerateStructurePacket( return GenerateStructurePacket(location, levels, keepJigsaws) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: GenerateStructurePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: GenerateStructurePacket) { output.writePosition(value.location) output.writeVarInt(value.levels) output.writeBoolean(value.keepJigsaws) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/HeldItemSlotPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/HeldItemSlotPacket.kt index 601552f..f797034 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/HeldItemSlotPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/HeldItemSlotPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class HeldItemSlotPacket( val slotId: Short, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): HeldItemSlotPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): HeldItemSlotPacket { val slotId = input.readShort() return HeldItemSlotPacket(slotId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: HeldItemSlotPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: HeldItemSlotPacket) { output.writeShort(value.slotId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/KeepAlivePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/KeepAlivePacket.kt index 71407bb..da2fec0 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/KeepAlivePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/KeepAlivePacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class KeepAlivePacket( val keepAliveId: Long, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): KeepAlivePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): KeepAlivePacket { val keepAliveId = input.readLong() return KeepAlivePacket(keepAliveId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: KeepAlivePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: KeepAlivePacket) { output.writeLong(value.keepAliveId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/LockDifficultyPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/LockDifficultyPacket.kt index f3490b1..a59e5e2 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/LockDifficultyPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/LockDifficultyPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class LockDifficultyPacket( val locked: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): LockDifficultyPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): LockDifficultyPacket { val locked = input.readBoolean() return LockDifficultyPacket(locked) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: LockDifficultyPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: LockDifficultyPacket) { output.writeBoolean(value.locked) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/LookPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/LookPacket.kt index 07a2804..e467609 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/LookPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/LookPacket.kt @@ -19,9 +19,8 @@ data class LookPacket( val pitch: Float, val onGround: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): LookPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): LookPacket { val yaw = input.readFloat() val pitch = input.readFloat() val onGround = input.readBoolean() @@ -29,7 +28,7 @@ data class LookPacket( return LookPacket(yaw, pitch, onGround) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: LookPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: LookPacket) { output.writeFloat(value.yaw) output.writeFloat(value.pitch) output.writeBoolean(value.onGround) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/MessageAcknowledgementPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/MessageAcknowledgementPacket.kt index 2f6bc14..5c72d0d 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/MessageAcknowledgementPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/MessageAcknowledgementPacket.kt @@ -3,23 +3,31 @@ package io.layercraft.packetlib.packets.v1_19_2.play.serverbound import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface - +import java.util.UUID /** * Message Acknowledgment | 0x03 | play | serverbound * - + * @property hasLastMessage lastMessage is present + * @property sender sender * @see https://wiki.vg/Protocol#Message_Acknowledgment */ @MinecraftPacket(id = 0x03, state = PacketState.PLAY, direction = PacketDirection.SERVERBOUND) -class MessageAcknowledgementPacket() : ServerBoundPacket { - +data class MessageAcknowledgementPacket( + val hasLastMessage: Boolean, + val sender: UUID?, +) : ServerBoundPacket { companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): MessageAcknowledgementPacket { - return MessageAcknowledgementPacket() + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): MessageAcknowledgementPacket { + val hasLastMessage = input.readBoolean() + val sender = if (hasLastMessage) input.readUUID() else null + + return MessageAcknowledgementPacket(hasLastMessage, sender) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: MessageAcknowledgementPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: MessageAcknowledgementPacket) { + output.writeBoolean(value.hasLastMessage) + if (value.hasLastMessage) output.writeUUID(value.sender!!) } } } \ No newline at end of file diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/NameItemPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/NameItemPacket.kt index 62d7e85..e1386d0 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/NameItemPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/NameItemPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class NameItemPacket( val name: String, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): NameItemPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): NameItemPacket { val name = input.readString() return NameItemPacket(name) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: NameItemPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: NameItemPacket) { output.writeString(value.name) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PickItemPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PickItemPacket.kt index 90d0a79..fee9b16 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PickItemPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PickItemPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class PickItemPacket( val slot: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PickItemPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PickItemPacket { val slot = input.readVarInt() return PickItemPacket(slot) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PickItemPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PickItemPacket) { output.writeVarInt(value.slot) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PongPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PongPacket.kt index 53644c5..2c7773a 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PongPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PongPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class PongPacket( val id: Int, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PongPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PongPacket { val id = input.readInt() return PongPacket(id) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PongPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PongPacket) { output.writeInt(value.id) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PositionLookPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PositionLookPacket.kt index c83a308..e649cca 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PositionLookPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PositionLookPacket.kt @@ -25,9 +25,8 @@ data class PositionLookPacket( val pitch: Float, val onGround: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PositionLookPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PositionLookPacket { val x = input.readDouble() val y = input.readDouble() val z = input.readDouble() @@ -38,7 +37,7 @@ data class PositionLookPacket( return PositionLookPacket(x, y, z, yaw, pitch, onGround) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PositionLookPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PositionLookPacket) { output.writeDouble(value.x) output.writeDouble(value.y) output.writeDouble(value.z) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PositionPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PositionPacket.kt index 3dd0614..7debe35 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PositionPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/PositionPacket.kt @@ -21,9 +21,8 @@ data class PositionPacket( val z: Double, val onGround: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PositionPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PositionPacket { val x = input.readDouble() val y = input.readDouble() val z = input.readDouble() @@ -32,7 +31,7 @@ data class PositionPacket( return PositionPacket(x, y, z, onGround) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PositionPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PositionPacket) { output.writeDouble(value.x) output.writeDouble(value.y) output.writeDouble(value.z) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/QueryBlockNbtPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/QueryBlockNbtPacket.kt index 86d43ff..02db9d4 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/QueryBlockNbtPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/QueryBlockNbtPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Query Block Entity Tag | 0x01 | play | serverbound * @@ -18,16 +17,15 @@ data class QueryBlockNbtPacket( val transactionId: Int, // varint val location: Position, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): QueryBlockNbtPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): QueryBlockNbtPacket { val transactionId = input.readVarInt() val location = input.readPosition() return QueryBlockNbtPacket(transactionId, location) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: QueryBlockNbtPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: QueryBlockNbtPacket) { output.writeVarInt(value.transactionId) output.writePosition(value.location) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/QueryEntityNbtPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/QueryEntityNbtPacket.kt index 41e43c9..1714df1 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/QueryEntityNbtPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/QueryEntityNbtPacket.kt @@ -17,16 +17,15 @@ data class QueryEntityNbtPacket( val transactionId: Int, // varint val entityId: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): QueryEntityNbtPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): QueryEntityNbtPacket { val transactionId = input.readVarInt() val entityId = input.readVarInt() return QueryEntityNbtPacket(transactionId, entityId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: QueryEntityNbtPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: QueryEntityNbtPacket) { output.writeVarInt(value.transactionId) output.writeVarInt(value.entityId) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/RecipeBookPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/RecipeBookPacket.kt index 768e455..1b10a2e 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/RecipeBookPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/RecipeBookPacket.kt @@ -19,9 +19,8 @@ data class RecipeBookPacket( val bookOpen: Boolean, val filterActive: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): RecipeBookPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): RecipeBookPacket { val bookId = input.readVarInt() val bookOpen = input.readBoolean() val filterActive = input.readBoolean() @@ -29,7 +28,7 @@ data class RecipeBookPacket( return RecipeBookPacket(bookId, bookOpen, filterActive) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: RecipeBookPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: RecipeBookPacket) { output.writeVarInt(value.bookId) output.writeBoolean(value.bookOpen) output.writeBoolean(value.filterActive) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ResourcePackReceivePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ResourcePackReceivePacket.kt index b76ba95..d48a820 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ResourcePackReceivePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/ResourcePackReceivePacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class ResourcePackReceivePacket( val result: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ResourcePackReceivePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ResourcePackReceivePacket { val result = input.readVarInt() return ResourcePackReceivePacket(result) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ResourcePackReceivePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ResourcePackReceivePacket) { output.writeVarInt(value.result) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SelectTradePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SelectTradePacket.kt index 57ea369..4881a10 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SelectTradePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SelectTradePacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class SelectTradePacket( val slot: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SelectTradePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SelectTradePacket { val slot = input.readVarInt() return SelectTradePacket(slot) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SelectTradePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SelectTradePacket) { output.writeVarInt(value.slot) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetBeaconEffectPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetBeaconEffectPacket.kt index 39a221b..61c43fb 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetBeaconEffectPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetBeaconEffectPacket.kt @@ -21,9 +21,8 @@ data class SetBeaconEffectPacket( val hasSecondaryEffect: Boolean, val secondaryEffect: Int?, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SetBeaconEffectPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SetBeaconEffectPacket { val hasPrimaryEffect = input.readBoolean() val primaryEffect = if (hasPrimaryEffect) input.readVarInt() else null val hasSecondaryEffect = input.readBoolean() @@ -32,7 +31,7 @@ data class SetBeaconEffectPacket( return SetBeaconEffectPacket(hasPrimaryEffect, primaryEffect, hasSecondaryEffect, secondaryEffect) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SetBeaconEffectPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SetBeaconEffectPacket) { output.writeBoolean(value.hasPrimaryEffect) if (value.hasPrimaryEffect) output.writeVarInt(value.primaryEffect!!) output.writeBoolean(value.hasSecondaryEffect) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetCreativeSlotPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetCreativeSlotPacket.kt index 3732a0d..e6f42ba 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetCreativeSlotPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetCreativeSlotPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class SetCreativeSlotPacket( val slot: Short, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SetCreativeSlotPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SetCreativeSlotPacket { val slot = input.readShort() return SetCreativeSlotPacket(slot) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SetCreativeSlotPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SetCreativeSlotPacket) { output.writeShort(value.slot) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetDifficultyPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetDifficultyPacket.kt index 77b4a7f..7fc611f 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetDifficultyPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SetDifficultyPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class SetDifficultyPacket( val newDifficulty: UByte, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SetDifficultyPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SetDifficultyPacket { val newDifficulty = input.readUByte() return SetDifficultyPacket(newDifficulty) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SetDifficultyPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SetDifficultyPacket) { output.writeUByte(value.newDifficulty) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SettingsPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SettingsPacket.kt index c005005..908755d 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SettingsPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SettingsPacket.kt @@ -29,9 +29,8 @@ data class SettingsPacket( val enableTextFiltering: Boolean, val enableServerListing: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SettingsPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SettingsPacket { val locale = input.readString() val viewDistance = input.readByte() val chatFlags = input.readVarInt() @@ -44,7 +43,7 @@ data class SettingsPacket( return SettingsPacket(locale, viewDistance, chatFlags, chatColors, skinParts, mainHand, enableTextFiltering, enableServerListing) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SettingsPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SettingsPacket) { output.writeString(value.locale) output.writeByte(value.viewDistance) output.writeVarInt(value.chatFlags) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SpectatePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SpectatePacket.kt index 540c24e..d346be9 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SpectatePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SpectatePacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import java.util.UUID - /** * Teleport To Entity | 0x30 | play | serverbound * @@ -16,15 +15,14 @@ import java.util.UUID data class SpectatePacket( val target: UUID, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SpectatePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SpectatePacket { val target = input.readUUID() return SpectatePacket(target) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SpectatePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SpectatePacket) { output.writeUUID(value.target) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SteerBoatPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SteerBoatPacket.kt index be99dd8..4704d9b 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SteerBoatPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SteerBoatPacket.kt @@ -17,16 +17,15 @@ data class SteerBoatPacket( val leftPaddle: Boolean, val rightPaddle: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SteerBoatPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SteerBoatPacket { val leftPaddle = input.readBoolean() val rightPaddle = input.readBoolean() return SteerBoatPacket(leftPaddle, rightPaddle) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SteerBoatPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SteerBoatPacket) { output.writeBoolean(value.leftPaddle) output.writeBoolean(value.rightPaddle) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SteerVehiclePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SteerVehiclePacket.kt index 3793e1f..5d83889 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SteerVehiclePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/SteerVehiclePacket.kt @@ -19,9 +19,8 @@ data class SteerVehiclePacket( val forward: Float, val jump: UByte, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): SteerVehiclePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): SteerVehiclePacket { val sideways = input.readFloat() val forward = input.readFloat() val jump = input.readUByte() @@ -29,7 +28,7 @@ data class SteerVehiclePacket( return SteerVehiclePacket(sideways, forward, jump) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: SteerVehiclePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: SteerVehiclePacket) { output.writeFloat(value.sideways) output.writeFloat(value.forward) output.writeUByte(value.jump) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/TabCompletePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/TabCompletePacket.kt index 77daf90..98c5edb 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/TabCompletePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/TabCompletePacket.kt @@ -17,16 +17,15 @@ data class TabCompletePacket( val transactionId: Int, // varint val text: String, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): TabCompletePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): TabCompletePacket { val transactionId = input.readVarInt() val text = input.readString() return TabCompletePacket(transactionId, text) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: TabCompletePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: TabCompletePacket) { output.writeVarInt(value.transactionId) output.writeString(value.text) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/TeleportConfirmPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/TeleportConfirmPacket.kt index 34671ff..b92391b 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/TeleportConfirmPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/TeleportConfirmPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class TeleportConfirmPacket( val teleportId: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): TeleportConfirmPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): TeleportConfirmPacket { val teleportId = input.readVarInt() return TeleportConfirmPacket(teleportId) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: TeleportConfirmPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: TeleportConfirmPacket) { output.writeVarInt(value.teleportId) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateCommandBlockMinecartPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateCommandBlockMinecartPacket.kt index 86e2097..9019a6b 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateCommandBlockMinecartPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateCommandBlockMinecartPacket.kt @@ -19,9 +19,8 @@ data class UpdateCommandBlockMinecartPacket( val command: String, val trackOutput: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateCommandBlockMinecartPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateCommandBlockMinecartPacket { val entityId = input.readVarInt() val command = input.readString() val trackOutput = input.readBoolean() @@ -29,7 +28,7 @@ data class UpdateCommandBlockMinecartPacket( return UpdateCommandBlockMinecartPacket(entityId, command, trackOutput) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateCommandBlockMinecartPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateCommandBlockMinecartPacket) { output.writeVarInt(value.entityId) output.writeString(value.command) output.writeBoolean(value.trackOutput) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateCommandBlockPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateCommandBlockPacket.kt index 3b81757..df2a8de 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateCommandBlockPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateCommandBlockPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Program Command Block | 0x29 | play | serverbound * @@ -22,9 +21,8 @@ data class UpdateCommandBlockPacket( val mode: Int, // varint val flags: UByte, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateCommandBlockPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateCommandBlockPacket { val location = input.readPosition() val command = input.readString() val mode = input.readVarInt() @@ -33,7 +31,7 @@ data class UpdateCommandBlockPacket( return UpdateCommandBlockPacket(location, command, mode, flags) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateCommandBlockPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateCommandBlockPacket) { output.writePosition(value.location) output.writeString(value.command) output.writeVarInt(value.mode) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateJigsawBlockPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateJigsawBlockPacket.kt index 51ca619..a866854 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateJigsawBlockPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateJigsawBlockPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Use Item | 0x2c | play | serverbound * @@ -26,9 +25,8 @@ data class UpdateJigsawBlockPacket( val finalState: String, val jointType: String, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateJigsawBlockPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateJigsawBlockPacket { val location = input.readPosition() val name = input.readString() val target = input.readString() @@ -39,7 +37,7 @@ data class UpdateJigsawBlockPacket( return UpdateJigsawBlockPacket(location, name, target, pool, finalState, jointType) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateJigsawBlockPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateJigsawBlockPacket) { output.writePosition(value.location) output.writeString(value.name) output.writeString(value.target) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateSignPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateSignPacket.kt index 5409c03..3fe1a5d 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateSignPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateSignPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Use Item | 0x2e | play | serverbound * @@ -24,9 +23,8 @@ data class UpdateSignPacket( val text3: String, val text4: String, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateSignPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateSignPacket { val location = input.readPosition() val text1 = input.readString() val text2 = input.readString() @@ -36,7 +34,7 @@ data class UpdateSignPacket( return UpdateSignPacket(location, text1, text2, text3, text4) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateSignPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateSignPacket) { output.writePosition(value.location) output.writeString(value.text1) output.writeString(value.text2) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateStructureBlockPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateStructureBlockPacket.kt index b4c46ca..3d323fa 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateStructureBlockPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UpdateStructureBlockPacket.kt @@ -4,7 +4,6 @@ import io.layercraft.packetlib.packets.* import io.layercraft.packetlib.serialization.MinecraftProtocolDeserializeInterface import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface import io.layercraft.packetlib.types.Position - /** * Use Item | 0x2d | play | serverbound * @@ -46,9 +45,8 @@ data class UpdateStructureBlockPacket( val seed: Int, // varint val flags: UByte, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateStructureBlockPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UpdateStructureBlockPacket { val location = input.readPosition() val action = input.readVarInt() val mode = input.readVarInt() @@ -69,7 +67,7 @@ data class UpdateStructureBlockPacket( return UpdateStructureBlockPacket(location, action, mode, name, offsetX, offsetY, offsetZ, sizeX, sizeY, sizeZ, mirror, rotation, metadata, integrity, seed, flags) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateStructureBlockPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UpdateStructureBlockPacket) { output.writePosition(value.location) output.writeVarInt(value.action) output.writeVarInt(value.mode) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UseEntityPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UseEntityPacket.kt index f351a06..02e8f79 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UseEntityPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UseEntityPacket.kt @@ -9,6 +9,10 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface * * @property target target * @property mouse mouse + * @property x x + * @property y y + * @property z z + * @property hand hand * @property sneaking sneaking * @see https://wiki.vg/Protocol#Interact */ @@ -17,21 +21,58 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class UseEntityPacket( val target: Int, // varint val mouse: Int, // varint + val x: Float?, + val y: Float?, + val z: Float?, + val hand: Int?, // varint val sneaking: Boolean, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UseEntityPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UseEntityPacket { val target = input.readVarInt() val mouse = input.readVarInt() + val x = when (mouse) { + 2 -> input.readFloat() + else -> null + } + val y = when (mouse) { + 2 -> input.readFloat() + else -> null + } + val z = when (mouse) { + 2 -> input.readFloat() + else -> null + } + val hand = when (mouse) { + 0 -> input.readVarInt() + 2 -> input.readVarInt() + else -> null + } val sneaking = input.readBoolean() - return UseEntityPacket(target, mouse, sneaking) + return UseEntityPacket(target, mouse, x, y, z, hand, sneaking) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UseEntityPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UseEntityPacket) { output.writeVarInt(value.target) output.writeVarInt(value.mouse) + when (value.mouse) { + 2 -> output.writeFloat(value.x!!) + else -> {} + } + when (value.mouse) { + 2 -> output.writeFloat(value.y!!) + else -> {} + } + when (value.mouse) { + 2 -> output.writeFloat(value.z!!) + else -> {} + } + when (value.mouse) { + 0 -> output.writeVarInt(value.hand!!) + 2 -> output.writeVarInt(value.hand!!) + else -> {} + } output.writeBoolean(value.sneaking) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UseItemPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UseItemPacket.kt index c9cc641..ab6a896 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UseItemPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/UseItemPacket.kt @@ -17,16 +17,15 @@ data class UseItemPacket( val hand: Int, // varint val sequence: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): UseItemPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): UseItemPacket { val hand = input.readVarInt() val sequence = input.readVarInt() return UseItemPacket(hand, sequence) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: UseItemPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: UseItemPacket) { output.writeVarInt(value.hand) output.writeVarInt(value.sequence) } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/VehicleMovePacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/VehicleMovePacket.kt index 04aef77..2cadf53 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/VehicleMovePacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/VehicleMovePacket.kt @@ -23,9 +23,8 @@ data class VehicleMovePacket( val yaw: Float, val pitch: Float, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): VehicleMovePacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): VehicleMovePacket { val x = input.readDouble() val y = input.readDouble() val z = input.readDouble() @@ -35,7 +34,7 @@ data class VehicleMovePacket( return VehicleMovePacket(x, y, z, yaw, pitch) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: VehicleMovePacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: VehicleMovePacket) { output.writeDouble(value.x) output.writeDouble(value.y) output.writeDouble(value.z) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/WindowClickPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/WindowClickPacket.kt index f5f5bd8..897a6df 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/WindowClickPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/play/serverbound/WindowClickPacket.kt @@ -23,9 +23,8 @@ data class WindowClickPacket( val mouseButton: Byte, val mode: Int, // varint ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): WindowClickPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): WindowClickPacket { val windowId = input.readUByte() val stateId = input.readVarInt() val slot = input.readShort() @@ -35,7 +34,7 @@ data class WindowClickPacket( return WindowClickPacket(windowId, stateId, slot, mouseButton, mode) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: WindowClickPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: WindowClickPacket) { output.writeUByte(value.windowId) output.writeVarInt(value.stateId) output.writeShort(value.slot) diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/clientbound/PingPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/clientbound/PingPacket.kt index be6c49c..0615612 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/clientbound/PingPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/clientbound/PingPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class PingPacket( val time: Long, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PingPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PingPacket { val time = input.readLong() return PingPacket(time) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PingPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PingPacket) { output.writeLong(value.time) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/clientbound/ServerInfoPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/clientbound/ServerInfoPacket.kt index b2b1b88..9189b0c 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/clientbound/ServerInfoPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/clientbound/ServerInfoPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class ServerInfoPacket( val response: String, ) : ClientBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): ServerInfoPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): ServerInfoPacket { val response = input.readString() return ServerInfoPacket(response) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: ServerInfoPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: ServerInfoPacket) { output.writeString(value.response) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/serverbound/PingPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/serverbound/PingPacket.kt index 0470c39..bda1dde 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/serverbound/PingPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/serverbound/PingPacket.kt @@ -15,15 +15,14 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface data class PingPacket( val time: Long, ) : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PingPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PingPacket { val time = input.readLong() return PingPacket(time) } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PingPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PingPacket) { output.writeLong(value.time) } } diff --git a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/serverbound/PingStartPacket.kt b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/serverbound/PingStartPacket.kt index d97be77..aac4bb4 100644 --- a/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/serverbound/PingStartPacket.kt +++ b/src/main/kotlin/io/layercraft/packetlib/packets/v1_19_2/status/serverbound/PingStartPacket.kt @@ -13,13 +13,12 @@ import io.layercraft.packetlib.serialization.MinecraftProtocolSerializeInterface @MinecraftPacket(id = 0x00, state = PacketState.STATUS, direction = PacketDirection.SERVERBOUND) class PingStartPacket() : ServerBoundPacket { - companion object : PacketSerializer { - override fun serialize(input: MinecraftProtocolDeserializeInterface<*>): PingStartPacket { + override fun deserialize(input: MinecraftProtocolDeserializeInterface<*>): PingStartPacket { return PingStartPacket() } - override fun deserialize(output: MinecraftProtocolSerializeInterface<*>, value: PingStartPacket) { + override fun serialize(output: MinecraftProtocolSerializeInterface<*>, value: PingStartPacket) { } } } \ No newline at end of file