From 0a314bca16f6de199c319ffb0d84a5d5c3a61387 Mon Sep 17 00:00:00 2001 From: mat Date: Tue, 24 May 2022 20:28:08 -0500 Subject: rename code-generator to codegen --- codegen/lib/download.py | 89 ++++++++++++++++++++++ codegen/lib/mappings.py | 60 +++++++++++++++ codegen/lib/packetcodegen.py | 170 +++++++++++++++++++++++++++++++++++++++++++ codegen/lib/utils.py | 15 ++++ 4 files changed, 334 insertions(+) create mode 100644 codegen/lib/download.py create mode 100644 codegen/lib/mappings.py create mode 100644 codegen/lib/packetcodegen.py create mode 100644 codegen/lib/utils.py (limited to 'codegen/lib') diff --git a/codegen/lib/download.py b/codegen/lib/download.py new file mode 100644 index 00000000..284591ab --- /dev/null +++ b/codegen/lib/download.py @@ -0,0 +1,89 @@ +from .mappings import Mappings +import requests +import json +import os + +# make sure the downloads directory exists +if not os.path.exists('downloads'): + os.mkdir('downloads') + + +def get_burger(): + if not os.path.exists('downloads/Burger'): + with open('burger.json', 'w') as f: + json.dump(requests.get( + 'https://api.github.com/repos/Burger/Burger/releases/latest').json(), f) + print('\033[92mDownloading Burger...\033[m') + os.system( + 'cd downloads && git clone https://github.com/pokechu22/Burger && cd Burger && git pull') + + print('\033[92mInstalling dependencies...\033[m') + os.system('cd downloads/Burger && pip install six jawa') + + +def get_version_manifest(): + if not os.path.exists(f'downloads/version_manifest.json'): + print( + f'\033[92mDownloading version manifest...\033[m') + version_manifest_data = requests.get( + 'https://launchermeta.mojang.com/mc/game/version_manifest.json').json() + with open(f'downloads/version_manifest.json', 'w') as f: + json.dump(version_manifest_data, f) + else: + with open(f'downloads/version_manifest.json', 'r') as f: + version_manifest_data = json.load(f) + return version_manifest_data + + +def get_version_data(version_id: str): + if not os.path.exists(f'downloads/{version_id}.json'): + version_manifest_data = get_version_manifest() + + print( + f'\033[92mGetting data for \033[1m{version_id}..\033[m') + package_url = next( + filter(lambda v: v['id'] == version_id, version_manifest_data['versions']))['url'] + package_data = requests.get(package_url).json() + with open(f'downloads/{version_id}.json', 'w') as f: + json.dump(package_data, f) + else: + with open(f'downloads/{version_id}.json', 'r') as f: + package_data = json.load(f) + return package_data + + +def get_client_jar(version_id: str): + if not os.path.exists(f'downloads/client-{version_id}.jar'): + package_data = get_version_data(version_id) + print('\033[92mDownloading client jar...\033[m') + client_jar_url = package_data['downloads']['client']['url'] + with open(f'downloads/client-{version_id}.jar', 'wb') as f: + f.write(requests.get(client_jar_url).content) + + +def get_burger_data_for_version(version_id: str): + if not os.path.exists(f'downloads/burger-{version_id}.json'): + get_burger() + get_client_jar(version_id) + + os.system( + f'cd downloads/Burger && python munch.py ../client-{version_id}.jar --output ../burger-{version_id}.json' + ) + with open(f'downloads/burger-{version_id}.json', 'r') as f: + return json.load(f) + + +def get_mappings_for_version(version_id: str): + if not os.path.exists(f'downloads/mappings-{version_id}.txt'): + package_data = get_version_data(version_id) + + client_mappings_url = package_data['downloads']['client_mappings']['url'] + + mappings_text = requests.get(client_mappings_url).text + + with open(f'downloads/mappings-{version_id}.txt', 'w') as f: + f.write(mappings_text) + else: + with open(f'downloads/mappings-{version_id}.txt', 'r') as f: + mappings_text = f.read() + return Mappings.parse(mappings_text) diff --git a/codegen/lib/mappings.py b/codegen/lib/mappings.py new file mode 100644 index 00000000..fb3e8bda --- /dev/null +++ b/codegen/lib/mappings.py @@ -0,0 +1,60 @@ +class Mappings: + __slots__ = ('classes', 'fields', 'methods') + + def __init__(self, classes, fields, methods): + self.classes = classes + self.fields = fields + self.methods = methods + + @staticmethod + def parse(mappings_txt): + classes = {} + fields = {} + methods = {} + + current_obfuscated_class_name = None + + for line in mappings_txt.splitlines(): + if line.startswith('#') or line == '': + continue + + if line.startswith(' '): + # if a line starts with 4 spaces, that means it's a method or a field + if '(' in line: + # if it has an opening parenthesis, it's a method + real_name_with_parameters_and_line, obfuscated_name = line.strip().split(' -> ') + real_name_with_parameters = real_name_with_parameters_and_line.split( + ':')[-1] + + real_name = real_name_with_parameters.split('(')[0] + parameters = real_name_with_parameters.split('(')[1] + + if current_obfuscated_class_name not in methods: + methods[current_obfuscated_class_name] = {} + methods[current_obfuscated_class_name][ + f'{obfuscated_name}({parameters})'] = real_name + else: + # otherwise, it's a field + real_name_with_type, obfuscated_name = line.strip().split(' -> ') + real_name = real_name_with_type.split(' ')[1] + + if current_obfuscated_class_name not in fields: + fields[current_obfuscated_class_name] = {} + fields[current_obfuscated_class_name][obfuscated_name] = real_name + else: + # otherwise it's a class + real_name, obfuscated_name = line.strip(':').split(' -> ') + current_obfuscated_class_name = obfuscated_name + + classes[obfuscated_name] = real_name + + return Mappings(classes, fields, methods) + + def get_field(self, obfuscated_class_name, obfuscated_field_name): + return self.fields.get(obfuscated_class_name, {}).get(obfuscated_field_name) + + def get_class(self, obfuscated_class_name): + return self.classes[obfuscated_class_name] + + def get_method(self, obfuscated_class_name, obfuscated_method_name, obfuscated_signature): + return self.methods[obfuscated_class_name][f'{obfuscated_method_name}({obfuscated_signature})'] diff --git a/codegen/lib/packetcodegen.py b/codegen/lib/packetcodegen.py new file mode 100644 index 00000000..b4c6a83b --- /dev/null +++ b/codegen/lib/packetcodegen.py @@ -0,0 +1,170 @@ +from .utils import to_snake_case, to_camel_case +from .mappings import Mappings + + +def burger_type_to_rust_type(burger_type): + is_var = False + uses = set() + + if burger_type == 'byte': + field_type_rs = 'i8' + elif burger_type == 'short': + field_type_rs = 'i16' + elif burger_type == 'int': + field_type_rs = 'i32' + elif burger_type == 'long': + field_type_rs = 'i64' + elif burger_type == 'float': + field_type_rs = 'f32' + elif burger_type == 'double': + field_type_rs = 'f64' + + elif burger_type == 'varint': + is_var = True + field_type_rs = 'i32' + elif burger_type == 'varlong': + is_var = True + field_type_rs = 'i64' + + elif burger_type == 'boolean': + field_type_rs = 'bool' + elif burger_type == 'string': + field_type_rs = 'String' + + elif burger_type == 'chatcomponent': + field_type_rs = 'Component' + uses.add('azalea_chat::component::Component') + elif burger_type == 'identifier': + field_type_rs = 'ResourceLocation' + uses.add('azalea_core::resource_location::ResourceLocation') + elif burger_type == 'uuid': + field_type_rs = 'Uuid' + uses.add('uuid::Uuid') + elif burger_type == 'position': + field_type_rs = 'BlockPos' + uses.add('azalea_core::BlockPos') + elif burger_type == 'nbtcompound': + field_type_rs = 'azalea_nbt::Tag' + elif burger_type == 'itemstack': + field_type_rs = 'Slot' + uses.add('azalea_core::Slot') + elif burger_type == 'metadata': + field_type_rs = 'EntityMetadata' + uses.add('crate::mc_buf::EntityMetadata') + elif burger_type == 'enum': + # enums are too complicated, leave those to the user + field_type_rs = 'todo!()' + elif burger_type.endswith('[]'): + field_type_rs, is_var, uses = burger_type_to_rust_type( + burger_type[:-2]) + field_type_rs = f'Vec<{field_type_rs}>' + else: + print('Unknown field type:', burger_type) + exit() + return field_type_rs, is_var, uses + + +def write_packet_file(state, packet_name_snake_case, code): + with open(f'../azalea-protocol/src/packets/{state}/{packet_name_snake_case}.rs', 'w') as f: + f.write(code) + + +def generate(burger_packets, mappings: Mappings, target_packet_id, target_packet_direction, target_packet_state): + for packet in burger_packets.values(): + if packet['id'] != target_packet_id: + continue + + direction = packet['direction'].lower() # serverbound or clientbound + state = {'PLAY': 'game'}.get(packet['state'], packet['state'].lower()) + + if state != target_packet_state or direction != target_packet_direction: + continue + + generated_packet_code = [] + uses = set() + generated_packet_code.append( + f'#[derive(Clone, Debug, McBuf, {to_camel_case(state)}Packet)]') + uses.add(f'packet_macros::{{{to_camel_case(state)}Packet, McBuf}}') + + obfuscated_class_name = packet['class'].split('.')[0].split('$')[0] + class_name = mappings.get_class( + obfuscated_class_name).split('.')[-1].split('$')[0] + + generated_packet_code.append( + f'pub struct {to_camel_case(class_name)} {{') + + for instruction in packet.get('instructions', []): + if instruction['operation'] == 'write': + obfuscated_field_name = instruction['field'] + if '.' in obfuscated_field_name or ' ' in obfuscated_field_name or '(' in obfuscated_field_name: + generated_packet_code.append(f'// TODO: {instruction}') + continue + field_name = mappings.get_field( + obfuscated_class_name, obfuscated_field_name) + if not field_name: + generated_packet_code.append( + f'// TODO: unknown field {instruction}') + continue + + field_type = instruction['type'] + field_type_rs, is_var, instruction_uses = burger_type_to_rust_type( + field_type) + if is_var: + generated_packet_code.append('#[var]') + generated_packet_code.append( + f'pub {to_snake_case(field_name)}: {field_type_rs},') + uses.update(instruction_uses) + else: + generated_packet_code.append(f'// TODO: {instruction}') + continue + + generated_packet_code.append('}') + + if uses: + # empty line before the `use` statements + generated_packet_code.insert(0, '') + for use in uses: + generated_packet_code.insert(0, f'use {use};') + + print(generated_packet_code) + write_packet_file(state, to_snake_case(class_name), + '\n'.join(generated_packet_code)) + print() + + mod_rs_dir = f'../azalea-protocol/src/packets/{state}/mod.rs' + with open(mod_rs_dir, 'r') as f: + mod_rs = f.read().splitlines() + + pub_mod_line = f'pub mod {to_snake_case(class_name)};' + if pub_mod_line not in mod_rs: + mod_rs.insert(0, pub_mod_line) + packet_mod_rs_line = f' {hex(packet["id"])}: {to_snake_case(class_name)}::{to_camel_case(class_name)},' + + in_serverbound = False + in_clientbound = False + for i, line in enumerate(mod_rs): + if line.strip() == 'Serverbound => {': + in_serverbound = True + continue + elif line.strip() == 'Clientbound => {': + in_clientbound = True + continue + elif line.strip() in ('}', '},'): + if (in_serverbound and direction == 'serverbound') or (in_clientbound and direction == 'clientbound'): + mod_rs.insert(i, packet_mod_rs_line) + break + in_serverbound = in_clientbound = False + continue + + if line.strip() == '' or line.strip().startswith('//') or (not in_serverbound and direction == 'serverbound') or (not in_clientbound and direction == 'clientbound'): + continue + + line_packet_id_hex = line.strip().split(':')[0] + assert line_packet_id_hex.startswith('0x') + line_packet_id = int(line_packet_id_hex[2:], 16) + if line_packet_id > packet['id']: + mod_rs.insert(i, packet_mod_rs_line) + break + + with open(mod_rs_dir, 'w') as f: + f.write('\n'.join(mod_rs)) diff --git a/codegen/lib/utils.py b/codegen/lib/utils.py new file mode 100644 index 00000000..5336d574 --- /dev/null +++ b/codegen/lib/utils.py @@ -0,0 +1,15 @@ +import urllib.request +import gzip +import json +import re +import io + + +def to_snake_case(name): + s = re.sub('([A-Z])', r'_\1', name) + return s.lower().strip('_') + + +def to_camel_case(name): + s = re.sub('_([a-z])', lambda m: m.group(1).upper(), name) + return s[0].upper() + s[1:] -- cgit v1.2.3 From fb3b002d94076de463e2af776666387db9e75835 Mon Sep 17 00:00:00 2001 From: mat Date: Tue, 24 May 2022 23:05:44 -0500 Subject: start adding migrate --- codegen/burger.json | 1 - codegen/lib/code/packet.py | 148 +++++++++++++++++++++++++++++++++++++ codegen/lib/code/utils.py | 73 +++++++++++++++++++ codegen/lib/code/version.py | 31 ++++++++ codegen/lib/packetcodegen.py | 170 ------------------------------------------- codegen/lib/utils.py | 12 +-- codegen/migrate.py | 52 +++++++++++++ codegen/newpacket.py | 8 +- 8 files changed, 314 insertions(+), 181 deletions(-) delete mode 100644 codegen/burger.json create mode 100644 codegen/lib/code/packet.py create mode 100644 codegen/lib/code/utils.py create mode 100644 codegen/lib/code/version.py delete mode 100644 codegen/lib/packetcodegen.py create mode 100644 codegen/migrate.py (limited to 'codegen/lib') diff --git a/codegen/burger.json b/codegen/burger.json deleted file mode 100644 index 4fa39aa3..00000000 --- a/codegen/burger.json +++ /dev/null @@ -1 +0,0 @@ -{"message": "Not Found", "documentation_url": "https://docs.github.com/rest/reference/repos#get-the-latest-release"} \ No newline at end of file diff --git a/codegen/lib/code/packet.py b/codegen/lib/code/packet.py new file mode 100644 index 00000000..0d3ad138 --- /dev/null +++ b/codegen/lib/code/packet.py @@ -0,0 +1,148 @@ +from .utils import burger_type_to_rust_type, write_packet_file +from ..utils import padded_hex, to_snake_case, to_camel_case +from ..mappings import Mappings + + +def make_packet_mod_rs_line(packet_id: int, packet_class_name: str): + return f' {padded_hex(packet_id)}: {to_snake_case(packet_class_name)}::{to_camel_case(packet_class_name)},' + + +def generate(burger_packets, mappings: Mappings, target_packet_id, target_packet_direction, target_packet_state): + for packet in burger_packets.values(): + if packet['id'] != target_packet_id: + continue + + direction = packet['direction'].lower() # serverbound or clientbound + state = {'PLAY': 'game'}.get(packet['state'], packet['state'].lower()) + + if state != target_packet_state or direction != target_packet_direction: + continue + + generated_packet_code = [] + uses = set() + generated_packet_code.append( + f'#[derive(Clone, Debug, McBuf, {to_camel_case(state)}Packet)]') + uses.add(f'packet_macros::{{{to_camel_case(state)}Packet, McBuf}}') + + obfuscated_class_name = packet['class'].split('.')[0].split('$')[0] + class_name = mappings.get_class( + obfuscated_class_name).split('.')[-1].split('$')[0] + + generated_packet_code.append( + f'pub struct {to_camel_case(class_name)} {{') + + for instruction in packet.get('instructions', []): + if instruction['operation'] == 'write': + obfuscated_field_name = instruction['field'] + if '.' in obfuscated_field_name or ' ' in obfuscated_field_name or '(' in obfuscated_field_name: + generated_packet_code.append(f'// TODO: {instruction}') + continue + field_name = mappings.get_field( + obfuscated_class_name, obfuscated_field_name) + if not field_name: + generated_packet_code.append( + f'// TODO: unknown field {instruction}') + continue + + field_type = instruction['type'] + field_type_rs, is_var, instruction_uses = burger_type_to_rust_type( + field_type) + if is_var: + generated_packet_code.append('#[var]') + generated_packet_code.append( + f'pub {to_snake_case(field_name)}: {field_type_rs},') + uses.update(instruction_uses) + else: + generated_packet_code.append(f'// TODO: {instruction}') + continue + + generated_packet_code.append('}') + + if uses: + # empty line before the `use` statements + generated_packet_code.insert(0, '') + for use in uses: + generated_packet_code.insert(0, f'use {use};') + + print(generated_packet_code) + write_packet_file(state, to_snake_case(class_name), + '\n'.join(generated_packet_code)) + print() + + mod_rs_dir = f'../azalea-protocol/src/packets/{state}/mod.rs' + with open(mod_rs_dir, 'r') as f: + mod_rs = f.read().splitlines() + + pub_mod_line = f'pub mod {to_snake_case(class_name)};' + if pub_mod_line not in mod_rs: + mod_rs.insert(0, pub_mod_line) + packet_mod_rs_line = make_packet_mod_rs_line( + packet['id'], class_name) + + in_serverbound = False + in_clientbound = False + for i, line in enumerate(mod_rs): + if line.strip() == 'Serverbound => {': + in_serverbound = True + continue + elif line.strip() == 'Clientbound => {': + in_clientbound = True + continue + elif line.strip() in ('}', '},'): + if (in_serverbound and direction == 'serverbound') or (in_clientbound and direction == 'clientbound'): + mod_rs.insert(i, packet_mod_rs_line) + break + in_serverbound = in_clientbound = False + continue + + if line.strip() == '' or line.strip().startswith('//') or (not in_serverbound and direction == 'serverbound') or (not in_clientbound and direction == 'clientbound'): + continue + + line_packet_id_hex = line.strip().split(':')[0] + assert line_packet_id_hex.startswith('0x') + line_packet_id = int(line_packet_id_hex[2:], 16) + if line_packet_id > packet['id']: + mod_rs.insert(i, packet_mod_rs_line) + break + + with open(mod_rs_dir, 'w') as f: + f.write('\n'.join(mod_rs)) + + +def set_packet_ids(packet_ids: list, packet_class_names: list, direction: str, state: str): + assert len(packet_ids) == len(packet_class_names) + + mod_rs_dir = f'../azalea-protocol/src/packets/{state}/mod.rs' + with open(mod_rs_dir, 'r') as f: + mod_rs = f.read().splitlines() + new_mod_rs = [] + + ignore_lines = False + + for line in mod_rs: + if line.strip() == 'Serverbound => {': + if direction == 'serverbound': + ignore_lines = True + for packet_id, packet_class_name in zip(packet_ids, packet_class_names): + new_mod_rs.append( + make_packet_mod_rs_line(packet_id, packet_class_name) + ) + else: + ignore_lines = False + elif line.strip() == 'Clientbound => {': + if direction == 'serverbound': + ignore_lines = True + for packet_id, packet_class_name in zip(packet_ids, packet_class_names): + new_mod_rs.append( + make_packet_mod_rs_line(packet_id, packet_class_name) + ) + else: + ignore_lines = False + elif line.strip() in ('}', '},'): + ignore_lines = False + + if not ignore_lines: + new_mod_rs.append(line) + + with open(mod_rs_dir, 'w') as f: + f.write('\n'.join(new_mod_rs)) diff --git a/codegen/lib/code/utils.py b/codegen/lib/code/utils.py new file mode 100644 index 00000000..92d1a9e9 --- /dev/null +++ b/codegen/lib/code/utils.py @@ -0,0 +1,73 @@ + +import os + + +def burger_type_to_rust_type(burger_type): + is_var = False + uses = set() + + if burger_type == 'byte': + field_type_rs = 'i8' + elif burger_type == 'short': + field_type_rs = 'i16' + elif burger_type == 'int': + field_type_rs = 'i32' + elif burger_type == 'long': + field_type_rs = 'i64' + elif burger_type == 'float': + field_type_rs = 'f32' + elif burger_type == 'double': + field_type_rs = 'f64' + + elif burger_type == 'varint': + is_var = True + field_type_rs = 'i32' + elif burger_type == 'varlong': + is_var = True + field_type_rs = 'i64' + + elif burger_type == 'boolean': + field_type_rs = 'bool' + elif burger_type == 'string': + field_type_rs = 'String' + + elif burger_type == 'chatcomponent': + field_type_rs = 'Component' + uses.add('azalea_chat::component::Component') + elif burger_type == 'identifier': + field_type_rs = 'ResourceLocation' + uses.add('azalea_core::resource_location::ResourceLocation') + elif burger_type == 'uuid': + field_type_rs = 'Uuid' + uses.add('uuid::Uuid') + elif burger_type == 'position': + field_type_rs = 'BlockPos' + uses.add('azalea_core::BlockPos') + elif burger_type == 'nbtcompound': + field_type_rs = 'azalea_nbt::Tag' + elif burger_type == 'itemstack': + field_type_rs = 'Slot' + uses.add('azalea_core::Slot') + elif burger_type == 'metadata': + field_type_rs = 'EntityMetadata' + uses.add('crate::mc_buf::EntityMetadata') + elif burger_type == 'enum': + # enums are too complicated, leave those to the user + field_type_rs = 'todo!()' + elif burger_type.endswith('[]'): + field_type_rs, is_var, uses = burger_type_to_rust_type( + burger_type[:-2]) + field_type_rs = f'Vec<{field_type_rs}>' + else: + print('Unknown field type:', burger_type) + exit() + return field_type_rs, is_var, uses + + +def write_packet_file(state, packet_name_snake_case, code): + with open(f'../azalea-protocol/src/packets/{state}/{packet_name_snake_case}.rs', 'w') as f: + f.write(code) + + +def fmt(): + os.system('cd .. && cargo fmt') diff --git a/codegen/lib/code/version.py b/codegen/lib/code/version.py new file mode 100644 index 00000000..b7e5cbcc --- /dev/null +++ b/codegen/lib/code/version.py @@ -0,0 +1,31 @@ +import re + +README_DIR = '../README.md' +VERSION_REGEX = r'\*Currently supported Minecraft version: `(.*)`.\*' + + +def get_version_id() -> str: + with open(README_DIR, 'r') as f: + readme_text = f.read() + + version_line_match = re.search(VERSION_REGEX, readme_text) + if version_line_match: + version_id = version_line_match.group(1) + return version_id + else: + raise Exception('Could not find version id in README.md') + + +def set_version_id(version_id: str) -> None: + with open(README_DIR, 'r') as f: + readme_text = f.read() + + version_line_match = re.search(VERSION_REGEX, readme_text) + if version_line_match: + readme_text = readme_text.replace( + version_line_match.group(1), version_id) + else: + raise Exception('Could not find version id in README.md') + + with open(README_DIR, 'w') as f: + f.write(readme_text) diff --git a/codegen/lib/packetcodegen.py b/codegen/lib/packetcodegen.py deleted file mode 100644 index b4c6a83b..00000000 --- a/codegen/lib/packetcodegen.py +++ /dev/null @@ -1,170 +0,0 @@ -from .utils import to_snake_case, to_camel_case -from .mappings import Mappings - - -def burger_type_to_rust_type(burger_type): - is_var = False - uses = set() - - if burger_type == 'byte': - field_type_rs = 'i8' - elif burger_type == 'short': - field_type_rs = 'i16' - elif burger_type == 'int': - field_type_rs = 'i32' - elif burger_type == 'long': - field_type_rs = 'i64' - elif burger_type == 'float': - field_type_rs = 'f32' - elif burger_type == 'double': - field_type_rs = 'f64' - - elif burger_type == 'varint': - is_var = True - field_type_rs = 'i32' - elif burger_type == 'varlong': - is_var = True - field_type_rs = 'i64' - - elif burger_type == 'boolean': - field_type_rs = 'bool' - elif burger_type == 'string': - field_type_rs = 'String' - - elif burger_type == 'chatcomponent': - field_type_rs = 'Component' - uses.add('azalea_chat::component::Component') - elif burger_type == 'identifier': - field_type_rs = 'ResourceLocation' - uses.add('azalea_core::resource_location::ResourceLocation') - elif burger_type == 'uuid': - field_type_rs = 'Uuid' - uses.add('uuid::Uuid') - elif burger_type == 'position': - field_type_rs = 'BlockPos' - uses.add('azalea_core::BlockPos') - elif burger_type == 'nbtcompound': - field_type_rs = 'azalea_nbt::Tag' - elif burger_type == 'itemstack': - field_type_rs = 'Slot' - uses.add('azalea_core::Slot') - elif burger_type == 'metadata': - field_type_rs = 'EntityMetadata' - uses.add('crate::mc_buf::EntityMetadata') - elif burger_type == 'enum': - # enums are too complicated, leave those to the user - field_type_rs = 'todo!()' - elif burger_type.endswith('[]'): - field_type_rs, is_var, uses = burger_type_to_rust_type( - burger_type[:-2]) - field_type_rs = f'Vec<{field_type_rs}>' - else: - print('Unknown field type:', burger_type) - exit() - return field_type_rs, is_var, uses - - -def write_packet_file(state, packet_name_snake_case, code): - with open(f'../azalea-protocol/src/packets/{state}/{packet_name_snake_case}.rs', 'w') as f: - f.write(code) - - -def generate(burger_packets, mappings: Mappings, target_packet_id, target_packet_direction, target_packet_state): - for packet in burger_packets.values(): - if packet['id'] != target_packet_id: - continue - - direction = packet['direction'].lower() # serverbound or clientbound - state = {'PLAY': 'game'}.get(packet['state'], packet['state'].lower()) - - if state != target_packet_state or direction != target_packet_direction: - continue - - generated_packet_code = [] - uses = set() - generated_packet_code.append( - f'#[derive(Clone, Debug, McBuf, {to_camel_case(state)}Packet)]') - uses.add(f'packet_macros::{{{to_camel_case(state)}Packet, McBuf}}') - - obfuscated_class_name = packet['class'].split('.')[0].split('$')[0] - class_name = mappings.get_class( - obfuscated_class_name).split('.')[-1].split('$')[0] - - generated_packet_code.append( - f'pub struct {to_camel_case(class_name)} {{') - - for instruction in packet.get('instructions', []): - if instruction['operation'] == 'write': - obfuscated_field_name = instruction['field'] - if '.' in obfuscated_field_name or ' ' in obfuscated_field_name or '(' in obfuscated_field_name: - generated_packet_code.append(f'// TODO: {instruction}') - continue - field_name = mappings.get_field( - obfuscated_class_name, obfuscated_field_name) - if not field_name: - generated_packet_code.append( - f'// TODO: unknown field {instruction}') - continue - - field_type = instruction['type'] - field_type_rs, is_var, instruction_uses = burger_type_to_rust_type( - field_type) - if is_var: - generated_packet_code.append('#[var]') - generated_packet_code.append( - f'pub {to_snake_case(field_name)}: {field_type_rs},') - uses.update(instruction_uses) - else: - generated_packet_code.append(f'// TODO: {instruction}') - continue - - generated_packet_code.append('}') - - if uses: - # empty line before the `use` statements - generated_packet_code.insert(0, '') - for use in uses: - generated_packet_code.insert(0, f'use {use};') - - print(generated_packet_code) - write_packet_file(state, to_snake_case(class_name), - '\n'.join(generated_packet_code)) - print() - - mod_rs_dir = f'../azalea-protocol/src/packets/{state}/mod.rs' - with open(mod_rs_dir, 'r') as f: - mod_rs = f.read().splitlines() - - pub_mod_line = f'pub mod {to_snake_case(class_name)};' - if pub_mod_line not in mod_rs: - mod_rs.insert(0, pub_mod_line) - packet_mod_rs_line = f' {hex(packet["id"])}: {to_snake_case(class_name)}::{to_camel_case(class_name)},' - - in_serverbound = False - in_clientbound = False - for i, line in enumerate(mod_rs): - if line.strip() == 'Serverbound => {': - in_serverbound = True - continue - elif line.strip() == 'Clientbound => {': - in_clientbound = True - continue - elif line.strip() in ('}', '},'): - if (in_serverbound and direction == 'serverbound') or (in_clientbound and direction == 'clientbound'): - mod_rs.insert(i, packet_mod_rs_line) - break - in_serverbound = in_clientbound = False - continue - - if line.strip() == '' or line.strip().startswith('//') or (not in_serverbound and direction == 'serverbound') or (not in_clientbound and direction == 'clientbound'): - continue - - line_packet_id_hex = line.strip().split(':')[0] - assert line_packet_id_hex.startswith('0x') - line_packet_id = int(line_packet_id_hex[2:], 16) - if line_packet_id > packet['id']: - mod_rs.insert(i, packet_mod_rs_line) - break - - with open(mod_rs_dir, 'w') as f: - f.write('\n'.join(mod_rs)) diff --git a/codegen/lib/utils.py b/codegen/lib/utils.py index 5336d574..051ffe51 100644 --- a/codegen/lib/utils.py +++ b/codegen/lib/utils.py @@ -1,15 +1,15 @@ -import urllib.request -import gzip -import json import re -import io -def to_snake_case(name): +def to_snake_case(name: str): s = re.sub('([A-Z])', r'_\1', name) return s.lower().strip('_') -def to_camel_case(name): +def to_camel_case(name: str): s = re.sub('_([a-z])', lambda m: m.group(1).upper(), name) return s[0].upper() + s[1:] + + +def padded_hex(n: int): + return f'0x{n:02x}' diff --git a/codegen/migrate.py b/codegen/migrate.py new file mode 100644 index 00000000..c0748400 --- /dev/null +++ b/codegen/migrate.py @@ -0,0 +1,52 @@ +import lib.code.utils +import lib.code.version +import lib.download +import sys +import os + +old_version_id = lib.code.version.get_version_id() +old_mappings = lib.download.get_mappings_for_version(old_version_id) +old_burger_data = lib.download.get_burger_data_for_version(old_version_id) +old_packet_list = list(old_burger_data[0]['packets']['packet'].values()) + +new_version_id = sys.argv[1] +new_mappings = lib.download.get_mappings_for_version(new_version_id) +new_burger_data = lib.download.get_burger_data_for_version(new_version_id) +new_packet_list = list(new_burger_data[0]['packets']['packet'].values()) + +old_packet_ids = {} +new_packet_ids = {} + +for packet in old_packet_list: + assert packet['class'].endswith('.class') + packet_name = old_mappings.get_class(packet['class'][:-6]) + old_packet_ids[packet_name] = packet['id'] +for packet in new_packet_list: + assert packet['class'].endswith('.class') + packet_name = new_mappings.get_class(packet['class'][:-6]) + new_packet_ids[packet_name] = packet['id'] + +# find packets that changed ids +for packet_name in old_packet_ids: + if packet_name in new_packet_ids: + if old_packet_ids[packet_name] != new_packet_ids[packet_name]: + print(packet_name, 'id changed from', + old_packet_ids[packet_name], 'to', new_packet_ids[packet_name]) + +print() + +# find removed packets +for packet_name in old_packet_ids: + if packet_name not in new_packet_ids: + print(packet_name, 'removed') + +print() + +# find added packets +for packet_name in new_packet_ids: + if packet_name not in old_packet_ids: + print(packet_name, 'added') + +lib.code.utils.fmt() + +print('Done!') diff --git a/codegen/newpacket.py b/codegen/newpacket.py index f4dc172e..b3a1c64f 100644 --- a/codegen/newpacket.py +++ b/codegen/newpacket.py @@ -1,4 +1,4 @@ -from lib import download, packetcodegen # type: ignore +from lib import download, code # type: ignore import sys import os @@ -9,9 +9,9 @@ burger_packets_data = burger_data[0]['packets']['packet'] packet_id, direction, state = int(sys.argv[1]), sys.argv[2], sys.argv[3] print( f'Generating code for packet id: {packet_id} with direction {direction} and state {state}') -packetcodegen.generate(burger_packets_data, mappings, - packet_id, direction, state) +code.packetcodegen.generate(burger_packets_data, mappings, + packet_id, direction, state) -os.system('cd .. && cargo fmt') +code.fmt() print('Done!') -- cgit v1.2.3 From 479c05474704a5a2f68b79468d2cde05c0ceec62 Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 00:21:05 -0500 Subject: Migrate might be working --- codegen/lib/code/packet.py | 72 ++++++++++++++++++++++++++++++++++++++++++++-- codegen/lib/code/utils.py | 2 ++ codegen/lib/utils.py | 25 ++++++++++++++++ codegen/migrate.py | 51 ++++++++++++++++++++------------ codegen/newpacket.py | 4 +-- 5 files changed, 132 insertions(+), 22 deletions(-) (limited to 'codegen/lib') diff --git a/codegen/lib/code/packet.py b/codegen/lib/code/packet.py index 0d3ad138..59c773c1 100644 --- a/codegen/lib/code/packet.py +++ b/codegen/lib/code/packet.py @@ -7,7 +7,7 @@ def make_packet_mod_rs_line(packet_id: int, packet_class_name: str): return f' {padded_hex(packet_id)}: {to_snake_case(packet_class_name)}::{to_camel_case(packet_class_name)},' -def generate(burger_packets, mappings: Mappings, target_packet_id, target_packet_direction, target_packet_state): +def generate_packet(burger_packets, mappings: Mappings, target_packet_id, target_packet_direction, target_packet_state): for packet in burger_packets.values(): if packet['id'] != target_packet_id: continue @@ -109,9 +109,13 @@ def generate(burger_packets, mappings: Mappings, target_packet_id, target_packet f.write('\n'.join(mod_rs)) -def set_packet_ids(packet_ids: list, packet_class_names: list, direction: str, state: str): +def set_packets(packet_ids: list, packet_class_names: list, direction: str, state: str): assert len(packet_ids) == len(packet_class_names) + # sort the packets by id + packet_ids, packet_class_names = [list(x) for x in zip( + *sorted(zip(packet_ids, packet_class_names), key=lambda pair: pair[0]))] + mod_rs_dir = f'../azalea-protocol/src/packets/{state}/mod.rs' with open(mod_rs_dir, 'r') as f: mod_rs = f.read().splitlines() @@ -146,3 +150,67 @@ def set_packet_ids(packet_ids: list, packet_class_names: list, direction: str, s with open(mod_rs_dir, 'w') as f: f.write('\n'.join(new_mod_rs)) + + +def get_packets(direction: str, state: str): + mod_rs_dir = f'../azalea-protocol/src/packets/{state}/mod.rs' + with open(mod_rs_dir, 'r') as f: + mod_rs = f.read().splitlines() + + in_serverbound = False + in_clientbound = False + + packet_ids: list[int] = [] + packet_class_names: list[str] = [] + + for line in mod_rs: + if line.strip() == 'Serverbound => {': + in_serverbound = True + continue + elif line.strip() == 'Clientbound => {': + in_clientbound = True + continue + elif line.strip() in ('}', '},'): + if (in_serverbound and direction == 'serverbound') or (in_clientbound and direction == 'clientbound'): + break + in_serverbound = in_clientbound = False + continue + + if line.strip() == '' or line.strip().startswith('//') or (not in_serverbound and direction == 'serverbound') or (not in_clientbound and direction == 'clientbound'): + continue + + line_packet_id_hex = line.strip().split(':')[0] + assert line_packet_id_hex.startswith('0x') + line_packet_id = int(line_packet_id_hex[2:], 16) + packet_ids.append(line_packet_id) + + packet_class_name = line.strip().split(':')[1].strip() + packet_class_names.append(packet_class_name) + + return packet_ids, packet_class_names + + +def change_packet_ids(id_map: dict[int, int], direction: str, state: str): + existing_packet_ids, existing_packet_class_names = get_packets( + direction, state) + + new_packet_ids = [] + + for packet_id in existing_packet_ids: + new_packet_id = id_map.get(packet_id, packet_id) + new_packet_ids.append(new_packet_id) + + set_packets(new_packet_ids, existing_packet_class_names, direction, state) + + +def remove_packet_ids(packet_ids: list[int], direction: str, state: str): + existing_packet_ids, existing_packet_class_names = get_packets( + direction, state) + + new_packet_ids = [] + + for packet_id in existing_packet_ids: + if packet_id not in packet_ids: + new_packet_ids.append(packet_id) + + set_packets(new_packet_ids, existing_packet_class_names, direction, state) diff --git a/codegen/lib/code/utils.py b/codegen/lib/code/utils.py index 92d1a9e9..28a5ef3c 100644 --- a/codegen/lib/code/utils.py +++ b/codegen/lib/code/utils.py @@ -1,6 +1,8 @@ import os +# utilities specifically for codegen + def burger_type_to_rust_type(burger_type): is_var = False diff --git a/codegen/lib/utils.py b/codegen/lib/utils.py index 051ffe51..ff1a5d36 100644 --- a/codegen/lib/utils.py +++ b/codegen/lib/utils.py @@ -1,5 +1,7 @@ import re +# utilities that could be used for things other than codegen + def to_snake_case(name: str): s = re.sub('([A-Z])', r'_\1', name) @@ -13,3 +15,26 @@ def to_camel_case(name: str): def padded_hex(n: int): return f'0x{n:02x}' + + +class PacketIdentifier: + def __init__(self, packet_id, direction, state): + self.packet_id = packet_id + self.direction = direction + self.state = state + + def __eq__(self, other): + return self.packet_id == other.packet_id and self.direction == other.direction and self.state == other.state + + def __hash__(self): + return hash((self.packet_id, self.direction, self.state)) + + +def group_packets(packets: list[PacketIdentifier]): + packet_groups: dict[tuple[str, str], list[int]] = {} + for packet in packets: + key = (packet.direction, packet.state) + if key not in packet_groups: + packet_groups[key] = [] + packet_groups[key].append(packet.packet_id) + return packet_groups diff --git a/codegen/migrate.py b/codegen/migrate.py index c0748400..6928cea1 100644 --- a/codegen/migrate.py +++ b/codegen/migrate.py @@ -1,5 +1,7 @@ +from codegen.lib.utils import PacketIdentifier, group_packets import lib.code.utils import lib.code.version +import lib.code.packet import lib.download import sys import os @@ -14,39 +16,52 @@ new_mappings = lib.download.get_mappings_for_version(new_version_id) new_burger_data = lib.download.get_burger_data_for_version(new_version_id) new_packet_list = list(new_burger_data[0]['packets']['packet'].values()) -old_packet_ids = {} -new_packet_ids = {} + +old_packets: dict[PacketIdentifier, str] = {} +new_packets: dict[PacketIdentifier, str] = {} for packet in old_packet_list: assert packet['class'].endswith('.class') packet_name = old_mappings.get_class(packet['class'][:-6]) - old_packet_ids[packet_name] = packet['id'] + old_packets[PacketIdentifier( + packet['id'], packet['direction'], packet['state'])] = packet_name for packet in new_packet_list: assert packet['class'].endswith('.class') packet_name = new_mappings.get_class(packet['class'][:-6]) - new_packet_ids[packet_name] = packet['id'] + new_packets[PacketIdentifier( + packet['id'], packet['direction'], packet['state'])] = packet_name -# find packets that changed ids -for packet_name in old_packet_ids: - if packet_name in new_packet_ids: - if old_packet_ids[packet_name] != new_packet_ids[packet_name]: - print(packet_name, 'id changed from', - old_packet_ids[packet_name], 'to', new_packet_ids[packet_name]) + +# find removed packets +removed_packets: list[PacketIdentifier] = [] +for packet in old_packets: + if packet not in new_packets: + removed_packets.append(packet) +for (direction, state), packets in group_packets(removed_packets).items(): + lib.code.packet.remove_packet_ids(packets, direction, state) print() -# find removed packets -for packet_name in old_packet_ids: - if packet_name not in new_packet_ids: - print(packet_name, 'removed') +# find packets that changed ids +changed_packets: dict[PacketIdentifier, int] = {} +for old_packet, old_packet_name in old_packets.items(): + for new_packet, new_packet_name in new_packets.items(): + if old_packet == new_packet and old_packet.packet_id != new_packet.packet_id: + changed_packets[old_packet] = new_packet.packet_id +for (direction, state), packets in group_packets(list(changed_packets.keys())).items(): + lib.code.packet.remove_packet_ids(packets, direction, state) + print() # find added packets -for packet_name in new_packet_ids: - if packet_name not in old_packet_ids: - print(packet_name, 'added') - +added_packets: list[PacketIdentifier] = [] +for packet in new_packets: + if packet not in old_packets: + added_packets.append(packet) +for packet in added_packets: + lib.code.packet.generate_packet( + new_burger_data, new_mappings, packet.packet_id, packet.direction, packet.state) lib.code.utils.fmt() print('Done!') diff --git a/codegen/newpacket.py b/codegen/newpacket.py index b3a1c64f..2e4c77d7 100644 --- a/codegen/newpacket.py +++ b/codegen/newpacket.py @@ -9,8 +9,8 @@ burger_packets_data = burger_data[0]['packets']['packet'] packet_id, direction, state = int(sys.argv[1]), sys.argv[2], sys.argv[3] print( f'Generating code for packet id: {packet_id} with direction {direction} and state {state}') -code.packetcodegen.generate(burger_packets_data, mappings, - packet_id, direction, state) +code.packetcodegen.generate_packet(burger_packets_data, mappings, + packet_id, direction, state) code.fmt() -- cgit v1.2.3 From dc5a9149a588f727f14f7d6d89908ba8fe87b642 Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 00:30:47 -0500 Subject: Fix migrate --- codegen/lib/utils.py | 8 +++++++- codegen/migrate.py | 17 ++++++++++------- 2 files changed, 17 insertions(+), 8 deletions(-) (limited to 'codegen/lib') diff --git a/codegen/lib/utils.py b/codegen/lib/utils.py index ff1a5d36..c185c0e5 100644 --- a/codegen/lib/utils.py +++ b/codegen/lib/utils.py @@ -18,7 +18,7 @@ def padded_hex(n: int): class PacketIdentifier: - def __init__(self, packet_id, direction, state): + def __init__(self, packet_id: int, direction: str, state: str): self.packet_id = packet_id self.direction = direction self.state = state @@ -29,6 +29,12 @@ class PacketIdentifier: def __hash__(self): return hash((self.packet_id, self.direction, self.state)) + def __str__(self): + return f'{self.packet_id} {self.direction} {self.state}' + + def __repr__(self): + return f'PacketIdentifier({self.packet_id}, {self.direction}, {self.state})' + def group_packets(packets: list[PacketIdentifier]): packet_groups: dict[tuple[str, str], list[int]] = {} diff --git a/codegen/migrate.py b/codegen/migrate.py index 6928cea1..7cd46058 100644 --- a/codegen/migrate.py +++ b/codegen/migrate.py @@ -1,4 +1,4 @@ -from codegen.lib.utils import PacketIdentifier, group_packets +from lib.utils import PacketIdentifier, group_packets import lib.code.utils import lib.code.version import lib.code.packet @@ -24,19 +24,19 @@ for packet in old_packet_list: assert packet['class'].endswith('.class') packet_name = old_mappings.get_class(packet['class'][:-6]) old_packets[PacketIdentifier( - packet['id'], packet['direction'], packet['state'])] = packet_name + packet['id'], packet['direction'].lower(), packet['state'].lower())] = packet_name for packet in new_packet_list: assert packet['class'].endswith('.class') packet_name = new_mappings.get_class(packet['class'][:-6]) new_packets[PacketIdentifier( - packet['id'], packet['direction'], packet['state'])] = packet_name - + packet['id'], packet['direction'].lower(), packet['state'].lower())] = packet_name # find removed packets removed_packets: list[PacketIdentifier] = [] for packet in old_packets: - if packet not in new_packets: + if packet not in new_packets or new_packets[packet] != old_packets[packet]: removed_packets.append(packet) + print('Removed packet:', packet) for (direction, state), packets in group_packets(removed_packets).items(): lib.code.packet.remove_packet_ids(packets, direction, state) @@ -48,6 +48,8 @@ for old_packet, old_packet_name in old_packets.items(): for new_packet, new_packet_name in new_packets.items(): if old_packet == new_packet and old_packet.packet_id != new_packet.packet_id: changed_packets[old_packet] = new_packet.packet_id + print('Changed packet id:', old_packet, '->', + new_packet, f'({new_packet_name})') for (direction, state), packets in group_packets(list(changed_packets.keys())).items(): lib.code.packet.remove_packet_ids(packets, direction, state) @@ -57,11 +59,12 @@ print() # find added packets added_packets: list[PacketIdentifier] = [] for packet in new_packets: - if packet not in old_packets: + if packet not in old_packets and new_packets[packet] == old_packets[packet]: added_packets.append(packet) + print('Added packet:', packet) for packet in added_packets: lib.code.packet.generate_packet( - new_burger_data, new_mappings, packet.packet_id, packet.direction, packet.state) + new_burger_data[0]['packets']['packet'], new_mappings, packet.packet_id, packet.direction, packet.state) lib.code.utils.fmt() print('Done!') -- cgit v1.2.3 From 8953cf43e25ca93103fbc3551ac658e1b56679df Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 00:35:53 -0500 Subject: Almost --- codegen/lib/code/packet.py | 22 ++++++++++++++-------- codegen/migrate.py | 5 +++-- 2 files changed, 17 insertions(+), 10 deletions(-) (limited to 'codegen/lib') diff --git a/codegen/lib/code/packet.py b/codegen/lib/code/packet.py index 59c773c1..f9135194 100644 --- a/codegen/lib/code/packet.py +++ b/codegen/lib/code/packet.py @@ -7,13 +7,17 @@ def make_packet_mod_rs_line(packet_id: int, packet_class_name: str): return f' {padded_hex(packet_id)}: {to_snake_case(packet_class_name)}::{to_camel_case(packet_class_name)},' +def fix_state(state: str): + return {'PLAY': 'game'}.get(state, state.lower()) + + def generate_packet(burger_packets, mappings: Mappings, target_packet_id, target_packet_direction, target_packet_state): for packet in burger_packets.values(): if packet['id'] != target_packet_id: continue direction = packet['direction'].lower() # serverbound or clientbound - state = {'PLAY': 'game'}.get(packet['state'], packet['state'].lower()) + state = fix_state(packet['state']) if state != target_packet_state or direction != target_packet_direction: continue @@ -109,12 +113,12 @@ def generate_packet(burger_packets, mappings: Mappings, target_packet_id, target f.write('\n'.join(mod_rs)) -def set_packets(packet_ids: list, packet_class_names: list, direction: str, state: str): +def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: str, state: str): assert len(packet_ids) == len(packet_class_names) # sort the packets by id - packet_ids, packet_class_names = [list(x) for x in zip( - *sorted(zip(packet_ids, packet_class_names), key=lambda pair: pair[0]))] + zipped_packets: list[tuple[int, str]] = [list(x) for x in zip( + *sorted(zip(packet_ids, packet_class_names), key=lambda pair: pair[0]))] # type: ignore mod_rs_dir = f'../azalea-protocol/src/packets/{state}/mod.rs' with open(mod_rs_dir, 'r') as f: @@ -127,7 +131,7 @@ def set_packets(packet_ids: list, packet_class_names: list, direction: str, stat if line.strip() == 'Serverbound => {': if direction == 'serverbound': ignore_lines = True - for packet_id, packet_class_name in zip(packet_ids, packet_class_names): + for packet_id, packet_class_name in zipped_packets: new_mod_rs.append( make_packet_mod_rs_line(packet_id, packet_class_name) ) @@ -136,7 +140,7 @@ def set_packets(packet_ids: list, packet_class_names: list, direction: str, stat elif line.strip() == 'Clientbound => {': if direction == 'serverbound': ignore_lines = True - for packet_id, packet_class_name in zip(packet_ids, packet_class_names): + for packet_id, packet_class_name in zipped_packets: new_mod_rs.append( make_packet_mod_rs_line(packet_id, packet_class_name) ) @@ -208,9 +212,11 @@ def remove_packet_ids(packet_ids: list[int], direction: str, state: str): direction, state) new_packet_ids = [] + new_packet_class_names = [] - for packet_id in existing_packet_ids: + for packet_id, packet_class_name in zip(existing_packet_ids, existing_packet_class_names): if packet_id not in packet_ids: new_packet_ids.append(packet_id) + new_packet_class_names.append(packet_class_name) - set_packets(new_packet_ids, existing_packet_class_names, direction, state) + set_packets(new_packet_ids, new_packet_class_names, direction, state) diff --git a/codegen/migrate.py b/codegen/migrate.py index 7cd46058..edcf85a7 100644 --- a/codegen/migrate.py +++ b/codegen/migrate.py @@ -1,3 +1,4 @@ +from lib.code.packet import fix_state from lib.utils import PacketIdentifier, group_packets import lib.code.utils import lib.code.version @@ -24,12 +25,12 @@ for packet in old_packet_list: assert packet['class'].endswith('.class') packet_name = old_mappings.get_class(packet['class'][:-6]) old_packets[PacketIdentifier( - packet['id'], packet['direction'].lower(), packet['state'].lower())] = packet_name + packet['id'], packet['direction'].lower(), fix_state(packet['state']))] = packet_name for packet in new_packet_list: assert packet['class'].endswith('.class') packet_name = new_mappings.get_class(packet['class'][:-6]) new_packets[PacketIdentifier( - packet['id'], packet['direction'].lower(), packet['state'].lower())] = packet_name + packet['id'], packet['direction'].lower(), fix_state(packet['state']))] = packet_name # find removed packets removed_packets: list[PacketIdentifier] = [] -- cgit v1.2.3 From d69f4445f31b0093d233fc052735c772bdab16b1 Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 00:40:23 -0500 Subject: Update packet.py --- codegen/lib/code/packet.py | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'codegen/lib') diff --git a/codegen/lib/code/packet.py b/codegen/lib/code/packet.py index f9135194..af41a390 100644 --- a/codegen/lib/code/packet.py +++ b/codegen/lib/code/packet.py @@ -129,6 +129,7 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: for line in mod_rs: if line.strip() == 'Serverbound => {': + new_mod_rs.append(line) if direction == 'serverbound': ignore_lines = True for packet_id, packet_class_name in zipped_packets: @@ -137,7 +138,9 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: ) else: ignore_lines = False + continue elif line.strip() == 'Clientbound => {': + new_mod_rs.append(line) if direction == 'serverbound': ignore_lines = True for packet_id, packet_class_name in zipped_packets: @@ -146,6 +149,7 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: ) else: ignore_lines = False + continue elif line.strip() in ('}', '},'): ignore_lines = False -- cgit v1.2.3 From c851204dd0c4b9eee8acc12c4de56b90e1bf041b Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 20:09:48 -0500 Subject: Fix detecting changed packet ids --- codegen/lib/download.py | 8 ++++++-- codegen/migrate.py | 16 ++++++++-------- 2 files changed, 14 insertions(+), 10 deletions(-) (limited to 'codegen/lib') diff --git a/codegen/lib/download.py b/codegen/lib/download.py index 284591ab..5030f8f3 100644 --- a/codegen/lib/download.py +++ b/codegen/lib/download.py @@ -41,8 +41,12 @@ def get_version_data(version_id: str): print( f'\033[92mGetting data for \033[1m{version_id}..\033[m') - package_url = next( - filter(lambda v: v['id'] == version_id, version_manifest_data['versions']))['url'] + try: + package_url = next( + filter(lambda v: v['id'] == version_id, version_manifest_data['versions']))['url'] + except StopIteration: + raise ValueError( + f'No version with id {version_id} found. Maybe delete downloads/version_manifest.json and try again?') package_data = requests.get(package_url).json() with open(f'downloads/{version_id}.json', 'w') as f: json.dump(package_data, f) diff --git a/codegen/migrate.py b/codegen/migrate.py index 304351d3..c623fd58 100644 --- a/codegen/migrate.py +++ b/codegen/migrate.py @@ -38,8 +38,8 @@ for packet, packet_name in old_packets.items(): if packet_name not in old_packets.values(): removed_packets.append(packet) print('Removed packet:', packet) -for (direction, state), packets in group_packets(removed_packets).items(): - lib.code.packet.remove_packet_ids(packets, direction, state) +# for (direction, state), packets in group_packets(removed_packets).items(): +# lib.code.packet.remove_packet_ids(packets, direction, state) print() @@ -47,13 +47,13 @@ print() changed_packets: dict[PacketIdentifier, int] = {} for old_packet, old_packet_name in old_packets.items(): for new_packet, new_packet_name in new_packets.items(): - if old_packet.direction == new_packet.direction and old_packet.state == new_packet.state and old_packet.packet_id != new_packet.packet_id: + if old_packet_name == new_packet_name and old_packet.direction == new_packet.direction and old_packet.state == new_packet.state and old_packet.packet_id != new_packet.packet_id: changed_packets[old_packet] = new_packet.packet_id print('Changed packet id:', old_packet, '->', new_packet, f'({new_packet_name})') break -for (direction, state), packets in group_packets(list(changed_packets.keys())).items(): - lib.code.packet.remove_packet_ids(packets, direction, state) +# for (direction, state), packets in group_packets(list(changed_packets.keys())).items(): +# lib.code.packet.remove_packet_ids(packets, direction, state) print() @@ -64,9 +64,9 @@ for packet, packet_name in new_packets.items(): if packet_name not in old_packets.values(): added_packets.append(packet) print('Added packet:', packet) -for packet in added_packets: - lib.code.packet.generate_packet( - new_burger_data[0]['packets']['packet'], new_mappings, packet.packet_id, packet.direction, packet.state) +# for packet in added_packets: +# lib.code.packet.generate_packet( +# new_burger_data[0]['packets']['packet'], new_mappings, packet.packet_id, packet.direction, packet.state) lib.code.utils.fmt() print('Done!') -- cgit v1.2.3 From 054c6e678bc015f674c2d15cb6432a46d81d5934 Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 20:24:41 -0500 Subject: fix set_packets maybe --- codegen/lib/code/packet.py | 6 +++--- codegen/migrate.py | 1 - 2 files changed, 3 insertions(+), 4 deletions(-) (limited to 'codegen/lib') diff --git a/codegen/lib/code/packet.py b/codegen/lib/code/packet.py index af41a390..8563e5b9 100644 --- a/codegen/lib/code/packet.py +++ b/codegen/lib/code/packet.py @@ -117,7 +117,7 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: assert len(packet_ids) == len(packet_class_names) # sort the packets by id - zipped_packets: list[tuple[int, str]] = [list(x) for x in zip( + packet_ids, packet_class_names = [list(x) for x in zip( *sorted(zip(packet_ids, packet_class_names), key=lambda pair: pair[0]))] # type: ignore mod_rs_dir = f'../azalea-protocol/src/packets/{state}/mod.rs' @@ -132,7 +132,7 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: new_mod_rs.append(line) if direction == 'serverbound': ignore_lines = True - for packet_id, packet_class_name in zipped_packets: + for packet_id, packet_class_name in zip(packet_ids, packet_class_names): new_mod_rs.append( make_packet_mod_rs_line(packet_id, packet_class_name) ) @@ -143,7 +143,7 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: new_mod_rs.append(line) if direction == 'serverbound': ignore_lines = True - for packet_id, packet_class_name in zipped_packets: + for packet_id, packet_class_name in zip(packet_ids, packet_class_names): new_mod_rs.append( make_packet_mod_rs_line(packet_id, packet_class_name) ) diff --git a/codegen/migrate.py b/codegen/migrate.py index 890186b8..392af9fe 100644 --- a/codegen/migrate.py +++ b/codegen/migrate.py @@ -58,7 +58,6 @@ for (direction, state), packets in group_packets(list(changed_packets.keys())).i new_packet_id = changed_packets[PacketIdentifier( old_packet_id, direction, state)] id_map[old_packet_id] = new_packet_id - lib.code.packet.change_packet_ids(id_map, direction, state) -- cgit v1.2.3 From 35511e83c3fc0d655686790ad662593f0406630a Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 20:28:46 -0500 Subject: more fix --- azalea-protocol/src/packets/game/mod.rs | 2 +- codegen/lib/code/packet.py | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) (limited to 'codegen/lib') diff --git a/azalea-protocol/src/packets/game/mod.rs b/azalea-protocol/src/packets/game/mod.rs index 883e03aa..7372435a 100755 --- a/azalea-protocol/src/packets/game/mod.rs +++ b/azalea-protocol/src/packets/game/mod.rs @@ -103,4 +103,4 @@ declare_state_packets!( 0x66: clientbound_update_recipes_packet::ClientboundUpdateRecipesPacket, 0x67: clientbound_update_tags_packet::ClientboundUpdateTagsPacket, } -); +); \ No newline at end of file diff --git a/codegen/lib/code/packet.py b/codegen/lib/code/packet.py index 8563e5b9..427a2f3e 100644 --- a/codegen/lib/code/packet.py +++ b/codegen/lib/code/packet.py @@ -141,7 +141,7 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: continue elif line.strip() == 'Clientbound => {': new_mod_rs.append(line) - if direction == 'serverbound': + if direction == 'clientbound': ignore_lines = True for packet_id, packet_class_name in zip(packet_ids, packet_class_names): new_mod_rs.append( @@ -211,7 +211,7 @@ def change_packet_ids(id_map: dict[int, int], direction: str, state: str): set_packets(new_packet_ids, existing_packet_class_names, direction, state) -def remove_packet_ids(packet_ids: list[int], direction: str, state: str): +def remove_packet_ids(removing_packet_ids: list[int], direction: str, state: str): existing_packet_ids, existing_packet_class_names = get_packets( direction, state) @@ -219,7 +219,7 @@ def remove_packet_ids(packet_ids: list[int], direction: str, state: str): new_packet_class_names = [] for packet_id, packet_class_name in zip(existing_packet_ids, existing_packet_class_names): - if packet_id not in packet_ids: + if packet_id not in removing_packet_ids: new_packet_ids.append(packet_id) new_packet_class_names.append(packet_class_name) -- cgit v1.2.3 From 03c50bf22b731dd0d6ab92b789a63a4c80d163bb Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 20:30:34 -0500 Subject: delete files of removed packets --- codegen/lib/code/packet.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'codegen/lib') diff --git a/codegen/lib/code/packet.py b/codegen/lib/code/packet.py index 427a2f3e..5d073d2b 100644 --- a/codegen/lib/code/packet.py +++ b/codegen/lib/code/packet.py @@ -1,6 +1,7 @@ from .utils import burger_type_to_rust_type, write_packet_file from ..utils import padded_hex, to_snake_case, to_camel_case from ..mappings import Mappings +import os def make_packet_mod_rs_line(packet_id: int, packet_class_name: str): @@ -222,5 +223,7 @@ def remove_packet_ids(removing_packet_ids: list[int], direction: str, state: str if packet_id not in removing_packet_ids: new_packet_ids.append(packet_id) new_packet_class_names.append(packet_class_name) + os.remove( + f'../azalea-protocol/src/packets/{state}/{packet_class_name}.rs') set_packets(new_packet_ids, new_packet_class_names, direction, state) -- cgit v1.2.3 From 053e5375b548c17bda126fa01e2ddce05f81ded5 Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 22:49:29 -0500 Subject: Update packet.py --- codegen/lib/code/packet.py | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) (limited to 'codegen/lib') diff --git a/codegen/lib/code/packet.py b/codegen/lib/code/packet.py index 5d073d2b..58cf8c38 100644 --- a/codegen/lib/code/packet.py +++ b/codegen/lib/code/packet.py @@ -126,7 +126,10 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: mod_rs = f.read().splitlines() new_mod_rs = [] - ignore_lines = False + required_modules = [] + + # set to true by default to ignore the `pub mod` lines since we add these later + ignore_lines = True for line in mod_rs: if line.strip() == 'Serverbound => {': @@ -137,6 +140,7 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: new_mod_rs.append( make_packet_mod_rs_line(packet_id, packet_class_name) ) + required_modules.append(packet_class_name) else: ignore_lines = False continue @@ -156,6 +160,14 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: if not ignore_lines: new_mod_rs.append(line) + # 0x00: clientbound_status_response_packet::ClientboundStatusResponsePacket, + if line.strip().startswith('0x'): + required_modules.append( + line.strip().split(':')[1].split('::')[0]) + + for i, required_module in enumerate(required_modules): + if required_module not in mod_rs: + new_mod_rs.insert(i, f'pub mod {required_module};') with open(mod_rs_dir, 'w') as f: f.write('\n'.join(new_mod_rs)) @@ -223,7 +235,5 @@ def remove_packet_ids(removing_packet_ids: list[int], direction: str, state: str if packet_id not in removing_packet_ids: new_packet_ids.append(packet_id) new_packet_class_names.append(packet_class_name) - os.remove( - f'../azalea-protocol/src/packets/{state}/{packet_class_name}.rs') set_packets(new_packet_ids, new_packet_class_names, direction, state) -- cgit v1.2.3 From 64eaa63e2368a2d26c5f8d843bd1642539670c70 Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 22:54:49 -0500 Subject: Migrate mod.rs works --- codegen/lib/code/packet.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) (limited to 'codegen/lib') diff --git a/codegen/lib/code/packet.py b/codegen/lib/code/packet.py index 58cf8c38..36e0ba0c 100644 --- a/codegen/lib/code/packet.py +++ b/codegen/lib/code/packet.py @@ -128,8 +128,7 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: required_modules = [] - # set to true by default to ignore the `pub mod` lines since we add these later - ignore_lines = True + ignore_lines = False for line in mod_rs: if line.strip() == 'Serverbound => {': @@ -157,13 +156,15 @@ def set_packets(packet_ids: list[int], packet_class_names: list[str], direction: continue elif line.strip() in ('}', '},'): ignore_lines = False + elif line.strip().startswith('pub mod '): + continue if not ignore_lines: new_mod_rs.append(line) # 0x00: clientbound_status_response_packet::ClientboundStatusResponsePacket, if line.strip().startswith('0x'): required_modules.append( - line.strip().split(':')[1].split('::')[0]) + line.strip().split(':')[1].split('::')[0].strip()) for i, required_module in enumerate(required_modules): if required_module not in mod_rs: @@ -232,7 +233,13 @@ def remove_packet_ids(removing_packet_ids: list[int], direction: str, state: str new_packet_class_names = [] for packet_id, packet_class_name in zip(existing_packet_ids, existing_packet_class_names): - if packet_id not in removing_packet_ids: + if packet_id in removing_packet_ids: + try: + os.remove( + f'../azalea-protocol/src/packets/{state}/{packet_class_name}.rs') + except: + pass + else: new_packet_ids.append(packet_id) new_packet_class_names.append(packet_class_name) -- cgit v1.2.3 From 3fbbb61c30f0833dd1e07802419ee91ef6cad8e3 Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 25 May 2022 22:59:05 -0500 Subject: set version ids --- codegen/lib/code/version.py | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) (limited to 'codegen/lib') diff --git a/codegen/lib/code/version.py b/codegen/lib/code/version.py index b7e5cbcc..77911f16 100644 --- a/codegen/lib/code/version.py +++ b/codegen/lib/code/version.py @@ -29,3 +29,26 @@ def set_version_id(version_id: str) -> None: with open(README_DIR, 'w') as f: f.write(readme_text) + +def get_protocol_version() -> str: + # azalea-protocol/src/packets/mod.rs + # pub const PROTOCOL_VERSION: u32 = 758; + with open('../azalea-protocol/src/packets/mod.rs', 'r') as f: + mod_rs = f.read().splitlines() + for line in mod_rs: + if line.strip().startswith('pub const PROTOCOL_VERSION'): + return line.strip().split(' ')[-1].strip(';') + raise Exception('Could not find protocol version in azalea-protocol/src/packets/mod.rs') + +def set_protocol_version(protocol_version: str) -> None: + with open('../azalea-protocol/src/packets/mod.rs', 'r') as f: + mod_rs = f.read().splitlines() + for i, line in enumerate(mod_rs): + if line.strip().startswith('pub const PROTOCOL_VERSION'): + mod_rs[i] = f'pub const PROTOCOL_VERSION: u32 = {protocol_version};' + break + else: + raise Exception('Could not find protocol version in azalea-protocol/src/packets/mod.rs') + + with open('../azalea-protocol/src/packets/mod.rs', 'w') as f: + f.write('\n'.join(mod_rs)) \ No newline at end of file -- cgit v1.2.3 From cb4b060f35ad45b8abab08d23f11eaa63f4cc459 Mon Sep 17 00:00:00 2001 From: mat Date: Fri, 27 May 2022 00:32:10 -0500 Subject: Fix version.py to work from any directory --- codegen/lib/code/version.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) (limited to 'codegen/lib') diff --git a/codegen/lib/code/version.py b/codegen/lib/code/version.py index 77911f16..e131a598 100644 --- a/codegen/lib/code/version.py +++ b/codegen/lib/code/version.py @@ -1,6 +1,7 @@ import re +import os -README_DIR = '../README.md' +README_DIR = os.path.join(os.path.dirname(__file__), '../../../README.md') VERSION_REGEX = r'\*Currently supported Minecraft version: `(.*)`.\*' @@ -30,6 +31,7 @@ def set_version_id(version_id: str) -> None: with open(README_DIR, 'w') as f: f.write(readme_text) + def get_protocol_version() -> str: # azalea-protocol/src/packets/mod.rs # pub const PROTOCOL_VERSION: u32 = 758; @@ -38,7 +40,9 @@ def get_protocol_version() -> str: for line in mod_rs: if line.strip().startswith('pub const PROTOCOL_VERSION'): return line.strip().split(' ')[-1].strip(';') - raise Exception('Could not find protocol version in azalea-protocol/src/packets/mod.rs') + raise Exception( + 'Could not find protocol version in azalea-protocol/src/packets/mod.rs') + def set_protocol_version(protocol_version: str) -> None: with open('../azalea-protocol/src/packets/mod.rs', 'r') as f: @@ -48,7 +52,8 @@ def set_protocol_version(protocol_version: str) -> None: mod_rs[i] = f'pub const PROTOCOL_VERSION: u32 = {protocol_version};' break else: - raise Exception('Could not find protocol version in azalea-protocol/src/packets/mod.rs') + raise Exception( + 'Could not find protocol version in azalea-protocol/src/packets/mod.rs') with open('../azalea-protocol/src/packets/mod.rs', 'w') as f: - f.write('\n'.join(mod_rs)) \ No newline at end of file + f.write('\n'.join(mod_rs)) -- cgit v1.2.3 From 05af65d16c06b6c2fd71908df6a68c5a8c57ba18 Mon Sep 17 00:00:00 2001 From: mat Date: Wed, 8 Jun 2022 18:32:28 -0500 Subject: no burger.json --- codegen/lib/download.py | 3 --- 1 file changed, 3 deletions(-) (limited to 'codegen/lib') diff --git a/codegen/lib/download.py b/codegen/lib/download.py index 5030f8f3..7d14a3a3 100644 --- a/codegen/lib/download.py +++ b/codegen/lib/download.py @@ -10,9 +10,6 @@ if not os.path.exists('downloads'): def get_burger(): if not os.path.exists('downloads/Burger'): - with open('burger.json', 'w') as f: - json.dump(requests.get( - 'https://api.github.com/repos/Burger/Burger/releases/latest').json(), f) print('\033[92mDownloading Burger...\033[m') os.system( 'cd downloads && git clone https://github.com/pokechu22/Burger && cd Burger && git pull') -- cgit v1.2.3