From 0b493d43f3ca93e30eaff089d6be681aa650e5e4 Mon Sep 17 00:00:00 2001 From: adman Date: Sun, 28 Dec 2025 17:58:47 +0100 Subject: [PATCH] packets upgrade --- proto_base/base_types.go | 10 + proto_generated/v1_21_8/helpers.go | 1285 --------------------------- proto_generated/version_switcher.go | 37 - proto_generator/helper_append.txt | 178 ---- proto_generator/helper_generator.go | 216 ++--- proto_generator/main.go | 44 +- proto_generator/printer.go | 35 +- proto_generator/utils.go | 24 +- proto_generator/version_swticher.go | 143 --- 9 files changed, 174 insertions(+), 1798 deletions(-) delete mode 100644 proto_generated/v1_21_8/helpers.go delete mode 100644 proto_generated/version_switcher.go delete mode 100644 proto_generator/helper_append.txt delete mode 100644 proto_generator/version_swticher.go diff --git a/proto_base/base_types.go b/proto_base/base_types.go index d1611c0..356f4e5 100644 --- a/proto_base/base_types.go +++ b/proto_base/base_types.go @@ -4,6 +4,7 @@ import ( "encoding/binary" "errors" "io" + "reflect" ) type Direction int @@ -210,3 +211,12 @@ type EncodeDecodeAble interface { Encode(w io.Writer) (err error) Decode(r io.Reader) (err error) } + +type PacketInfo struct { + Type reflect.Type + Name string + Direction Direction + State State + PacketId int + ProtocolVersion int +} diff --git a/proto_generated/v1_21_8/helpers.go b/proto_generated/v1_21_8/helpers.go deleted file mode 100644 index 788d3fc..0000000 --- a/proto_generated/v1_21_8/helpers.go +++ /dev/null @@ -1,1285 +0,0 @@ -package v1_21_8 - -import ( - "github.com/admin-else/strom/proto_base" - "io" -) - -func HandshakingToServerPacketIdentifierToType(s string) (t any) { - switch s { - case "legacy_server_list_ping": - t = HandshakingToServerPacketLegacyServerListPing{} - case "set_protocol": - t = HandshakingToServerPacketSetProtocol{} - default: - t = nil - } - return -} -func HandshakingToServerTypeToPacketIdentifier(t any) (s string) { - switch t.(type) { - case HandshakingToServerPacketLegacyServerListPing: - s = "legacy_server_list_ping" - case HandshakingToServerPacketSetProtocol: - s = "set_protocol" - } - return -} -func HandshakingToClientPacketIdentifierToType(s string) (t any) { - switch s { - default: - t = nil - } - return -} -func HandshakingToClientTypeToPacketIdentifier(t any) (s string) { - switch t.(type) { - } - return -} -func StatusToServerPacketIdentifierToType(s string) (t any) { - switch s { - case "ping": - t = StatusToServerPacketPing{} - case "ping_start": - t = StatusToServerPacketPingStart{} - default: - t = nil - } - return -} -func StatusToServerTypeToPacketIdentifier(t any) (s string) { - switch t.(type) { - case StatusToServerPacketPing: - s = "ping" - case StatusToServerPacketPingStart: - s = "ping_start" - } - return -} -func StatusToClientPacketIdentifierToType(s string) (t any) { - switch s { - case "ping": - t = StatusToClientPacketPing{} - case "server_info": - t = StatusToClientPacketServerInfo{} - default: - t = nil - } - return -} -func StatusToClientTypeToPacketIdentifier(t any) (s string) { - switch t.(type) { - case StatusToClientPacketPing: - s = "ping" - case StatusToClientPacketServerInfo: - s = "server_info" - } - return -} -func LoginToServerPacketIdentifierToType(s string) (t any) { - switch s { - case "cookie_response": - t = PacketCommonCookieResponse{} - case "encryption_begin": - t = LoginToServerPacketEncryptionBegin{} - case "login_acknowledged": - t = LoginToServerPacketLoginAcknowledged{} - case "login_plugin_response": - t = LoginToServerPacketLoginPluginResponse{} - case "login_start": - t = LoginToServerPacketLoginStart{} - default: - t = nil - } - return -} -func LoginToServerTypeToPacketIdentifier(t any) (s string) { - switch t.(type) { - case LoginToServerPacketEncryptionBegin: - s = "encryption_begin" - case LoginToServerPacketLoginAcknowledged: - s = "login_acknowledged" - case LoginToServerPacketLoginPluginResponse: - s = "login_plugin_response" - case LoginToServerPacketLoginStart: - s = "login_start" - case PacketCommonCookieResponse: - s = "cookie_response" - } - return -} -func LoginToClientPacketIdentifierToType(s string) (t any) { - switch s { - case "compress": - t = LoginToClientPacketCompress{} - case "cookie_request": - t = PacketCommonCookieRequest{} - case "disconnect": - t = LoginToClientPacketDisconnect{} - case "encryption_begin": - t = LoginToClientPacketEncryptionBegin{} - case "login_plugin_request": - t = LoginToClientPacketLoginPluginRequest{} - case "success": - t = LoginToClientPacketSuccess{} - default: - t = nil - } - return -} -func LoginToClientTypeToPacketIdentifier(t any) (s string) { - switch t.(type) { - case LoginToClientPacketCompress: - s = "compress" - case LoginToClientPacketDisconnect: - s = "disconnect" - case LoginToClientPacketEncryptionBegin: - s = "encryption_begin" - case LoginToClientPacketLoginPluginRequest: - s = "login_plugin_request" - case LoginToClientPacketSuccess: - s = "success" - case PacketCommonCookieRequest: - s = "cookie_request" - } - return -} -func ConfigurationToServerPacketIdentifierToType(s string) (t any) { - switch s { - case "cookie_response": - t = PacketCommonCookieResponse{} - case "custom_click_action": - t = PacketCommonCustomClickAction{} - case "custom_payload": - t = ConfigurationToServerPacketCustomPayload{} - case "finish_configuration": - t = ConfigurationToServerPacketFinishConfiguration{} - case "keep_alive": - t = ConfigurationToServerPacketKeepAlive{} - case "pong": - t = ConfigurationToServerPacketPong{} - case "resource_pack_receive": - t = ConfigurationToServerPacketResourcePackReceive{} - case "select_known_packs": - t = PacketCommonSelectKnownPacks{} - case "settings": - t = PacketCommonSettings{} - default: - t = nil - } - return -} -func ConfigurationToServerTypeToPacketIdentifier(t any) (s string) { - switch t.(type) { - case ConfigurationToServerPacketCustomPayload: - s = "custom_payload" - case ConfigurationToServerPacketFinishConfiguration: - s = "finish_configuration" - case ConfigurationToServerPacketKeepAlive: - s = "keep_alive" - case ConfigurationToServerPacketPong: - s = "pong" - case ConfigurationToServerPacketResourcePackReceive: - s = "resource_pack_receive" - case PacketCommonCookieResponse: - s = "cookie_response" - case PacketCommonCustomClickAction: - s = "custom_click_action" - case PacketCommonSelectKnownPacks: - s = "select_known_packs" - case PacketCommonSettings: - s = "settings" - } - return -} -func ConfigurationToClientPacketIdentifierToType(s string) (t any) { - switch s { - case "add_resource_pack": - t = PacketCommonAddResourcePack{} - case "clear_dialog": - t = PacketCommonClearDialog{} - case "cookie_request": - t = PacketCommonCookieRequest{} - case "custom_payload": - t = ConfigurationToClientPacketCustomPayload{} - case "custom_report_details": - t = PacketCommonCustomReportDetails{} - case "disconnect": - t = ConfigurationToClientPacketDisconnect{} - case "feature_flags": - t = ConfigurationToClientPacketFeatureFlags{} - case "finish_configuration": - t = ConfigurationToClientPacketFinishConfiguration{} - case "keep_alive": - t = ConfigurationToClientPacketKeepAlive{} - case "ping": - t = ConfigurationToClientPacketPing{} - case "registry_data": - t = ConfigurationToClientPacketRegistryData{} - case "remove_resource_pack": - t = PacketCommonRemoveResourcePack{} - case "reset_chat": - t = ConfigurationToClientPacketResetChat{} - case "select_known_packs": - t = PacketCommonSelectKnownPacks{} - case "server_links": - t = PacketCommonServerLinks{} - case "show_dialog": - t = ConfigurationToClientPacketShowDialog{} - case "store_cookie": - t = PacketCommonStoreCookie{} - case "tags": - t = ConfigurationToClientPacketTags{} - case "transfer": - t = PacketCommonTransfer{} - default: - t = nil - } - return -} -func ConfigurationToClientTypeToPacketIdentifier(t any) (s string) { - switch t.(type) { - case ConfigurationToClientPacketCustomPayload: - s = "custom_payload" - case ConfigurationToClientPacketDisconnect: - s = "disconnect" - case ConfigurationToClientPacketFeatureFlags: - s = "feature_flags" - case ConfigurationToClientPacketFinishConfiguration: - s = "finish_configuration" - case ConfigurationToClientPacketKeepAlive: - s = "keep_alive" - case ConfigurationToClientPacketPing: - s = "ping" - case ConfigurationToClientPacketRegistryData: - s = "registry_data" - case ConfigurationToClientPacketResetChat: - s = "reset_chat" - case ConfigurationToClientPacketShowDialog: - s = "show_dialog" - case ConfigurationToClientPacketTags: - s = "tags" - case PacketCommonAddResourcePack: - s = "add_resource_pack" - case PacketCommonClearDialog: - s = "clear_dialog" - case PacketCommonCookieRequest: - s = "cookie_request" - case PacketCommonCustomReportDetails: - s = "custom_report_details" - case PacketCommonRemoveResourcePack: - s = "remove_resource_pack" - case PacketCommonSelectKnownPacks: - s = "select_known_packs" - case PacketCommonServerLinks: - s = "server_links" - case PacketCommonStoreCookie: - s = "store_cookie" - case PacketCommonTransfer: - s = "transfer" - } - return -} -func PlayToServerPacketIdentifierToType(s string) (t any) { - switch s { - case "abilities": - t = PlayToServerPacketAbilities{} - case "advancement_tab": - t = PlayToServerPacketAdvancementTab{} - case "arm_animation": - t = PlayToServerPacketArmAnimation{} - case "block_dig": - t = PlayToServerPacketBlockDig{} - case "block_place": - t = PlayToServerPacketBlockPlace{} - case "change_gamemode": - t = PlayToServerPacketChangeGamemode{} - case "chat_command": - t = PlayToServerPacketChatCommand{} - case "chat_command_signed": - t = PlayToServerPacketChatCommandSigned{} - case "chat_message": - t = PlayToServerPacketChatMessage{} - case "chat_session_update": - t = PlayToServerPacketChatSessionUpdate{} - case "chunk_batch_received": - t = PlayToServerPacketChunkBatchReceived{} - case "client_command": - t = PlayToServerPacketClientCommand{} - case "close_window": - t = PlayToServerPacketCloseWindow{} - case "configuration_acknowledged": - t = PlayToServerPacketConfigurationAcknowledged{} - case "cookie_response": - t = PacketCommonCookieResponse{} - case "craft_recipe_request": - t = PlayToServerPacketCraftRecipeRequest{} - case "custom_click_action": - t = PacketCommonCustomClickAction{} - case "custom_payload": - t = PlayToServerPacketCustomPayload{} - case "debug_sample_subscription": - t = PlayToServerPacketDebugSampleSubscription{} - case "displayed_recipe": - t = PlayToServerPacketDisplayedRecipe{} - case "edit_book": - t = PlayToServerPacketEditBook{} - case "enchant_item": - t = PlayToServerPacketEnchantItem{} - case "entity_action": - t = PlayToServerPacketEntityAction{} - case "flying": - t = PlayToServerPacketFlying{} - case "generate_structure": - t = PlayToServerPacketGenerateStructure{} - case "held_item_slot": - t = PlayToServerPacketHeldItemSlot{} - case "keep_alive": - t = PlayToServerPacketKeepAlive{} - case "lock_difficulty": - t = PlayToServerPacketLockDifficulty{} - case "look": - t = PlayToServerPacketLook{} - case "message_acknowledgement": - t = PlayToServerPacketMessageAcknowledgement{} - case "name_item": - t = PlayToServerPacketNameItem{} - case "pick_item_from_block": - t = PlayToServerPacketPickItemFromBlock{} - case "pick_item_from_entity": - t = PlayToServerPacketPickItemFromEntity{} - case "ping_request": - t = PlayToServerPacketPingRequest{} - case "player_input": - t = PlayToServerPacketPlayerInput{} - case "player_loaded": - t = PlayToServerPacketPlayerLoaded{} - case "pong": - t = PlayToServerPacketPong{} - case "position": - t = PlayToServerPacketPosition{} - case "position_look": - t = PlayToServerPacketPositionLook{} - case "query_block_nbt": - t = PlayToServerPacketQueryBlockNbt{} - case "query_entity_nbt": - t = PlayToServerPacketQueryEntityNbt{} - case "recipe_book": - t = PlayToServerPacketRecipeBook{} - case "resource_pack_receive": - t = PlayToServerPacketResourcePackReceive{} - case "select_bundle_item": - t = PlayToServerPacketSelectBundleItem{} - case "select_trade": - t = PlayToServerPacketSelectTrade{} - case "set_beacon_effect": - t = PlayToServerPacketSetBeaconEffect{} - case "set_creative_slot": - t = PlayToServerPacketSetCreativeSlot{} - case "set_difficulty": - t = PlayToServerPacketSetDifficulty{} - case "set_slot_state": - t = PlayToServerPacketSetSlotState{} - case "set_test_block": - t = PlayToServerPacketSetTestBlock{} - case "settings": - t = PacketCommonSettings{} - case "spectate": - t = PlayToServerPacketSpectate{} - case "steer_boat": - t = PlayToServerPacketSteerBoat{} - case "tab_complete": - t = PlayToServerPacketTabComplete{} - case "teleport_confirm": - t = PlayToServerPacketTeleportConfirm{} - case "test_instance_block_action": - t = PlayToServerPacketTestInstanceBlockAction{} - case "tick_end": - t = PlayToServerPacketTickEnd{} - case "update_command_block": - t = PlayToServerPacketUpdateCommandBlock{} - case "update_command_block_minecart": - t = PlayToServerPacketUpdateCommandBlockMinecart{} - case "update_jigsaw_block": - t = PlayToServerPacketUpdateJigsawBlock{} - case "update_sign": - t = PlayToServerPacketUpdateSign{} - case "update_structure_block": - t = PlayToServerPacketUpdateStructureBlock{} - case "use_entity": - t = PlayToServerPacketUseEntity{} - case "use_item": - t = PlayToServerPacketUseItem{} - case "vehicle_move": - t = PlayToServerPacketVehicleMove{} - case "window_click": - t = PlayToServerPacketWindowClick{} - default: - t = nil - } - return -} -func PlayToServerTypeToPacketIdentifier(t any) (s string) { - switch t.(type) { - case PacketCommonCookieResponse: - s = "cookie_response" - case PacketCommonCustomClickAction: - s = "custom_click_action" - case PacketCommonSettings: - s = "settings" - case PlayToServerPacketAbilities: - s = "abilities" - case PlayToServerPacketAdvancementTab: - s = "advancement_tab" - case PlayToServerPacketArmAnimation: - s = "arm_animation" - case PlayToServerPacketBlockDig: - s = "block_dig" - case PlayToServerPacketBlockPlace: - s = "block_place" - case PlayToServerPacketChangeGamemode: - s = "change_gamemode" - case PlayToServerPacketChatCommand: - s = "chat_command" - case PlayToServerPacketChatCommandSigned: - s = "chat_command_signed" - case PlayToServerPacketChatMessage: - s = "chat_message" - case PlayToServerPacketChatSessionUpdate: - s = "chat_session_update" - case PlayToServerPacketChunkBatchReceived: - s = "chunk_batch_received" - case PlayToServerPacketClientCommand: - s = "client_command" - case PlayToServerPacketCloseWindow: - s = "close_window" - case PlayToServerPacketConfigurationAcknowledged: - s = "configuration_acknowledged" - case PlayToServerPacketCraftRecipeRequest: - s = "craft_recipe_request" - case PlayToServerPacketCustomPayload: - s = "custom_payload" - case PlayToServerPacketDebugSampleSubscription: - s = "debug_sample_subscription" - case PlayToServerPacketDisplayedRecipe: - s = "displayed_recipe" - case PlayToServerPacketEditBook: - s = "edit_book" - case PlayToServerPacketEnchantItem: - s = "enchant_item" - case PlayToServerPacketEntityAction: - s = "entity_action" - case PlayToServerPacketFlying: - s = "flying" - case PlayToServerPacketGenerateStructure: - s = "generate_structure" - case PlayToServerPacketHeldItemSlot: - s = "held_item_slot" - case PlayToServerPacketKeepAlive: - s = "keep_alive" - case PlayToServerPacketLockDifficulty: - s = "lock_difficulty" - case PlayToServerPacketLook: - s = "look" - case PlayToServerPacketMessageAcknowledgement: - s = "message_acknowledgement" - case PlayToServerPacketNameItem: - s = "name_item" - case PlayToServerPacketPickItemFromBlock: - s = "pick_item_from_block" - case PlayToServerPacketPickItemFromEntity: - s = "pick_item_from_entity" - case PlayToServerPacketPingRequest: - s = "ping_request" - case PlayToServerPacketPlayerInput: - s = "player_input" - case PlayToServerPacketPlayerLoaded: - s = "player_loaded" - case PlayToServerPacketPong: - s = "pong" - case PlayToServerPacketPosition: - s = "position" - case PlayToServerPacketPositionLook: - s = "position_look" - case PlayToServerPacketQueryBlockNbt: - s = "query_block_nbt" - case PlayToServerPacketQueryEntityNbt: - s = "query_entity_nbt" - case PlayToServerPacketRecipeBook: - s = "recipe_book" - case PlayToServerPacketResourcePackReceive: - s = "resource_pack_receive" - case PlayToServerPacketSelectBundleItem: - s = "select_bundle_item" - case PlayToServerPacketSelectTrade: - s = "select_trade" - case PlayToServerPacketSetBeaconEffect: - s = "set_beacon_effect" - case PlayToServerPacketSetCreativeSlot: - s = "set_creative_slot" - case PlayToServerPacketSetDifficulty: - s = "set_difficulty" - case PlayToServerPacketSetSlotState: - s = "set_slot_state" - case PlayToServerPacketSetTestBlock: - s = "set_test_block" - case PlayToServerPacketSpectate: - s = "spectate" - case PlayToServerPacketSteerBoat: - s = "steer_boat" - case PlayToServerPacketTabComplete: - s = "tab_complete" - case PlayToServerPacketTeleportConfirm: - s = "teleport_confirm" - case PlayToServerPacketTestInstanceBlockAction: - s = "test_instance_block_action" - case PlayToServerPacketTickEnd: - s = "tick_end" - case PlayToServerPacketUpdateCommandBlock: - s = "update_command_block" - case PlayToServerPacketUpdateCommandBlockMinecart: - s = "update_command_block_minecart" - case PlayToServerPacketUpdateJigsawBlock: - s = "update_jigsaw_block" - case PlayToServerPacketUpdateSign: - s = "update_sign" - case PlayToServerPacketUpdateStructureBlock: - s = "update_structure_block" - case PlayToServerPacketUseEntity: - s = "use_entity" - case PlayToServerPacketUseItem: - s = "use_item" - case PlayToServerPacketVehicleMove: - s = "vehicle_move" - case PlayToServerPacketWindowClick: - s = "window_click" - } - return -} -func PlayToClientPacketIdentifierToType(s string) (t any) { - switch s { - case "abilities": - t = PlayToClientPacketAbilities{} - case "acknowledge_player_digging": - t = PlayToClientPacketAcknowledgePlayerDigging{} - case "action_bar": - t = PlayToClientPacketActionBar{} - case "add_resource_pack": - t = PacketCommonAddResourcePack{} - case "advancements": - t = PlayToClientPacketAdvancements{} - case "animation": - t = PlayToClientPacketAnimation{} - case "attach_entity": - t = PlayToClientPacketAttachEntity{} - case "block_action": - t = PlayToClientPacketBlockAction{} - case "block_break_animation": - t = PlayToClientPacketBlockBreakAnimation{} - case "block_change": - t = PlayToClientPacketBlockChange{} - case "boss_bar": - t = PlayToClientPacketBossBar{} - case "bundle_delimiter": - t = proto_base.Void{} - case "camera": - t = PlayToClientPacketCamera{} - case "chat_suggestions": - t = PlayToClientPacketChatSuggestions{} - case "chunk_batch_finished": - t = PlayToClientPacketChunkBatchFinished{} - case "chunk_batch_start": - t = PlayToClientPacketChunkBatchStart{} - case "chunk_biomes": - t = PlayToClientPacketChunkBiomes{} - case "clear_dialog": - t = PacketCommonClearDialog{} - case "clear_titles": - t = PlayToClientPacketClearTitles{} - case "close_window": - t = PlayToClientPacketCloseWindow{} - case "collect": - t = PlayToClientPacketCollect{} - case "cookie_request": - t = PacketCommonCookieRequest{} - case "craft_progress_bar": - t = PlayToClientPacketCraftProgressBar{} - case "craft_recipe_response": - t = PlayToClientPacketCraftRecipeResponse{} - case "custom_payload": - t = PlayToClientPacketCustomPayload{} - case "custom_report_details": - t = PacketCommonCustomReportDetails{} - case "damage_event": - t = PlayToClientPacketDamageEvent{} - case "death_combat_event": - t = PlayToClientPacketDeathCombatEvent{} - case "debug_sample": - t = PlayToClientPacketDebugSample{} - case "declare_commands": - t = PlayToClientPacketDeclareCommands{} - case "declare_recipes": - t = PlayToClientPacketDeclareRecipes{} - case "difficulty": - t = PlayToClientPacketDifficulty{} - case "end_combat_event": - t = PlayToClientPacketEndCombatEvent{} - case "enter_combat_event": - t = PlayToClientPacketEnterCombatEvent{} - case "entity_destroy": - t = PlayToClientPacketEntityDestroy{} - case "entity_effect": - t = PlayToClientPacketEntityEffect{} - case "entity_equipment": - t = PlayToClientPacketEntityEquipment{} - case "entity_head_rotation": - t = PlayToClientPacketEntityHeadRotation{} - case "entity_look": - t = PlayToClientPacketEntityLook{} - case "entity_metadata": - t = PlayToClientPacketEntityMetadata{} - case "entity_move_look": - t = PlayToClientPacketEntityMoveLook{} - case "entity_sound_effect": - t = PlayToClientPacketEntitySoundEffect{} - case "entity_status": - t = PlayToClientPacketEntityStatus{} - case "entity_teleport": - t = PlayToClientPacketEntityTeleport{} - case "entity_update_attributes": - t = PlayToClientPacketEntityUpdateAttributes{} - case "entity_velocity": - t = PlayToClientPacketEntityVelocity{} - case "experience": - t = PlayToClientPacketExperience{} - case "explosion": - t = PlayToClientPacketExplosion{} - case "face_player": - t = PlayToClientPacketFacePlayer{} - case "game_state_change": - t = PlayToClientPacketGameStateChange{} - case "held_item_slot": - t = PlayToClientPacketHeldItemSlot{} - case "hide_message": - t = PlayToClientPacketHideMessage{} - case "hurt_animation": - t = PlayToClientPacketHurtAnimation{} - case "initialize_world_border": - t = PlayToClientPacketInitializeWorldBorder{} - case "keep_alive": - t = PlayToClientPacketKeepAlive{} - case "kick_disconnect": - t = PlayToClientPacketKickDisconnect{} - case "login": - t = PlayToClientPacketLogin{} - case "map": - t = PlayToClientPacketMap{} - case "map_chunk": - t = PlayToClientPacketMapChunk{} - case "move_minecart": - t = PlayToClientPacketMoveMinecart{} - case "multi_block_change": - t = PlayToClientPacketMultiBlockChange{} - case "nbt_query_response": - t = PlayToClientPacketNbtQueryResponse{} - case "open_book": - t = PlayToClientPacketOpenBook{} - case "open_horse_window": - t = PlayToClientPacketOpenHorseWindow{} - case "open_sign_entity": - t = PlayToClientPacketOpenSignEntity{} - case "open_window": - t = PlayToClientPacketOpenWindow{} - case "ping": - t = PlayToClientPacketPing{} - case "ping_response": - t = PlayToClientPacketPingResponse{} - case "player_chat": - t = PlayToClientPacketPlayerChat{} - case "player_info": - t = PlayToClientPacketPlayerInfo{} - case "player_remove": - t = PlayToClientPacketPlayerRemove{} - case "player_rotation": - t = PlayToClientPacketPlayerRotation{} - case "playerlist_header": - t = PlayToClientPacketPlayerlistHeader{} - case "position": - t = PlayToClientPacketPosition{} - case "profileless_chat": - t = PlayToClientPacketProfilelessChat{} - case "recipe_book_add": - t = PlayToClientPacketRecipeBookAdd{} - case "recipe_book_remove": - t = PlayToClientPacketRecipeBookRemove{} - case "recipe_book_settings": - t = PlayToClientPacketRecipeBookSettings{} - case "rel_entity_move": - t = PlayToClientPacketRelEntityMove{} - case "remove_entity_effect": - t = PlayToClientPacketRemoveEntityEffect{} - case "remove_resource_pack": - t = PacketCommonRemoveResourcePack{} - case "reset_score": - t = PlayToClientPacketResetScore{} - case "respawn": - t = PlayToClientPacketRespawn{} - case "scoreboard_display_objective": - t = PlayToClientPacketScoreboardDisplayObjective{} - case "scoreboard_objective": - t = PlayToClientPacketScoreboardObjective{} - case "scoreboard_score": - t = PlayToClientPacketScoreboardScore{} - case "select_advancement_tab": - t = PlayToClientPacketSelectAdvancementTab{} - case "server_data": - t = PlayToClientPacketServerData{} - case "server_links": - t = PacketCommonServerLinks{} - case "set_cooldown": - t = PlayToClientPacketSetCooldown{} - case "set_cursor_item": - t = PlayToClientPacketSetCursorItem{} - case "set_passengers": - t = PlayToClientPacketSetPassengers{} - case "set_player_inventory": - t = PlayToClientPacketSetPlayerInventory{} - case "set_projectile_power": - t = PlayToClientPacketSetProjectilePower{} - case "set_slot": - t = PlayToClientPacketSetSlot{} - case "set_ticking_state": - t = PlayToClientPacketSetTickingState{} - case "set_title_subtitle": - t = PlayToClientPacketSetTitleSubtitle{} - case "set_title_text": - t = PlayToClientPacketSetTitleText{} - case "set_title_time": - t = PlayToClientPacketSetTitleTime{} - case "show_dialog": - t = PlayToClientPacketShowDialog{} - case "simulation_distance": - t = PlayToClientPacketSimulationDistance{} - case "sound_effect": - t = PlayToClientPacketSoundEffect{} - case "spawn_entity": - t = PlayToClientPacketSpawnEntity{} - case "spawn_position": - t = PlayToClientPacketSpawnPosition{} - case "start_configuration": - t = PlayToClientPacketStartConfiguration{} - case "statistics": - t = PlayToClientPacketStatistics{} - case "step_tick": - t = PlayToClientPacketStepTick{} - case "stop_sound": - t = PlayToClientPacketStopSound{} - case "store_cookie": - t = PacketCommonStoreCookie{} - case "sync_entity_position": - t = PlayToClientPacketSyncEntityPosition{} - case "system_chat": - t = PlayToClientPacketSystemChat{} - case "tab_complete": - t = PlayToClientPacketTabComplete{} - case "tags": - t = PlayToClientPacketTags{} - case "teams": - t = PlayToClientPacketTeams{} - case "test_instance_block_status": - t = PlayToClientPacketTestInstanceBlockStatus{} - case "tile_entity_data": - t = PlayToClientPacketTileEntityData{} - case "tracked_waypoint": - t = PlayToClientPacketTrackedWaypoint{} - case "trade_list": - t = PlayToClientPacketTradeList{} - case "transfer": - t = PacketCommonTransfer{} - case "unload_chunk": - t = PlayToClientPacketUnloadChunk{} - case "update_health": - t = PlayToClientPacketUpdateHealth{} - case "update_light": - t = PlayToClientPacketUpdateLight{} - case "update_time": - t = PlayToClientPacketUpdateTime{} - case "update_view_distance": - t = PlayToClientPacketUpdateViewDistance{} - case "update_view_position": - t = PlayToClientPacketUpdateViewPosition{} - case "vehicle_move": - t = PlayToClientPacketVehicleMove{} - case "window_items": - t = PlayToClientPacketWindowItems{} - case "world_border_center": - t = PlayToClientPacketWorldBorderCenter{} - case "world_border_lerp_size": - t = PlayToClientPacketWorldBorderLerpSize{} - case "world_border_size": - t = PlayToClientPacketWorldBorderSize{} - case "world_border_warning_delay": - t = PlayToClientPacketWorldBorderWarningDelay{} - case "world_border_warning_reach": - t = PlayToClientPacketWorldBorderWarningReach{} - case "world_event": - t = PlayToClientPacketWorldEvent{} - case "world_particles": - t = PlayToClientPacketWorldParticles{} - default: - t = nil - } - return -} -func PlayToClientTypeToPacketIdentifier(t any) (s string) { - switch t.(type) { - case PacketCommonAddResourcePack: - s = "add_resource_pack" - case PacketCommonClearDialog: - s = "clear_dialog" - case PacketCommonCookieRequest: - s = "cookie_request" - case PacketCommonCustomReportDetails: - s = "custom_report_details" - case PacketCommonRemoveResourcePack: - s = "remove_resource_pack" - case PacketCommonServerLinks: - s = "server_links" - case PacketCommonStoreCookie: - s = "store_cookie" - case PacketCommonTransfer: - s = "transfer" - case PlayToClientPacketAbilities: - s = "abilities" - case PlayToClientPacketAcknowledgePlayerDigging: - s = "acknowledge_player_digging" - case PlayToClientPacketActionBar: - s = "action_bar" - case PlayToClientPacketAdvancements: - s = "advancements" - case PlayToClientPacketAnimation: - s = "animation" - case PlayToClientPacketAttachEntity: - s = "attach_entity" - case PlayToClientPacketBlockAction: - s = "block_action" - case PlayToClientPacketBlockBreakAnimation: - s = "block_break_animation" - case PlayToClientPacketBlockChange: - s = "block_change" - case PlayToClientPacketBossBar: - s = "boss_bar" - case PlayToClientPacketCamera: - s = "camera" - case PlayToClientPacketChatSuggestions: - s = "chat_suggestions" - case PlayToClientPacketChunkBatchFinished: - s = "chunk_batch_finished" - case PlayToClientPacketChunkBatchStart: - s = "chunk_batch_start" - case PlayToClientPacketChunkBiomes: - s = "chunk_biomes" - case PlayToClientPacketClearTitles: - s = "clear_titles" - case PlayToClientPacketCloseWindow: - s = "close_window" - case PlayToClientPacketCollect: - s = "collect" - case PlayToClientPacketCraftProgressBar: - s = "craft_progress_bar" - case PlayToClientPacketCraftRecipeResponse: - s = "craft_recipe_response" - case PlayToClientPacketCustomPayload: - s = "custom_payload" - case PlayToClientPacketDamageEvent: - s = "damage_event" - case PlayToClientPacketDeathCombatEvent: - s = "death_combat_event" - case PlayToClientPacketDebugSample: - s = "debug_sample" - case PlayToClientPacketDeclareCommands: - s = "declare_commands" - case PlayToClientPacketDeclareRecipes: - s = "declare_recipes" - case PlayToClientPacketDifficulty: - s = "difficulty" - case PlayToClientPacketEndCombatEvent: - s = "end_combat_event" - case PlayToClientPacketEnterCombatEvent: - s = "enter_combat_event" - case PlayToClientPacketEntityDestroy: - s = "entity_destroy" - case PlayToClientPacketEntityEffect: - s = "entity_effect" - case PlayToClientPacketEntityEquipment: - s = "entity_equipment" - case PlayToClientPacketEntityHeadRotation: - s = "entity_head_rotation" - case PlayToClientPacketEntityLook: - s = "entity_look" - case PlayToClientPacketEntityMetadata: - s = "entity_metadata" - case PlayToClientPacketEntityMoveLook: - s = "entity_move_look" - case PlayToClientPacketEntitySoundEffect: - s = "entity_sound_effect" - case PlayToClientPacketEntityStatus: - s = "entity_status" - case PlayToClientPacketEntityTeleport: - s = "entity_teleport" - case PlayToClientPacketEntityUpdateAttributes: - s = "entity_update_attributes" - case PlayToClientPacketEntityVelocity: - s = "entity_velocity" - case PlayToClientPacketExperience: - s = "experience" - case PlayToClientPacketExplosion: - s = "explosion" - case PlayToClientPacketFacePlayer: - s = "face_player" - case PlayToClientPacketGameStateChange: - s = "game_state_change" - case PlayToClientPacketHeldItemSlot: - s = "held_item_slot" - case PlayToClientPacketHideMessage: - s = "hide_message" - case PlayToClientPacketHurtAnimation: - s = "hurt_animation" - case PlayToClientPacketInitializeWorldBorder: - s = "initialize_world_border" - case PlayToClientPacketKeepAlive: - s = "keep_alive" - case PlayToClientPacketKickDisconnect: - s = "kick_disconnect" - case PlayToClientPacketLogin: - s = "login" - case PlayToClientPacketMap: - s = "map" - case PlayToClientPacketMapChunk: - s = "map_chunk" - case PlayToClientPacketMoveMinecart: - s = "move_minecart" - case PlayToClientPacketMultiBlockChange: - s = "multi_block_change" - case PlayToClientPacketNbtQueryResponse: - s = "nbt_query_response" - case PlayToClientPacketOpenBook: - s = "open_book" - case PlayToClientPacketOpenHorseWindow: - s = "open_horse_window" - case PlayToClientPacketOpenSignEntity: - s = "open_sign_entity" - case PlayToClientPacketOpenWindow: - s = "open_window" - case PlayToClientPacketPing: - s = "ping" - case PlayToClientPacketPingResponse: - s = "ping_response" - case PlayToClientPacketPlayerChat: - s = "player_chat" - case PlayToClientPacketPlayerInfo: - s = "player_info" - case PlayToClientPacketPlayerRemove: - s = "player_remove" - case PlayToClientPacketPlayerRotation: - s = "player_rotation" - case PlayToClientPacketPlayerlistHeader: - s = "playerlist_header" - case PlayToClientPacketPosition: - s = "position" - case PlayToClientPacketProfilelessChat: - s = "profileless_chat" - case PlayToClientPacketRecipeBookAdd: - s = "recipe_book_add" - case PlayToClientPacketRecipeBookRemove: - s = "recipe_book_remove" - case PlayToClientPacketRecipeBookSettings: - s = "recipe_book_settings" - case PlayToClientPacketRelEntityMove: - s = "rel_entity_move" - case PlayToClientPacketRemoveEntityEffect: - s = "remove_entity_effect" - case PlayToClientPacketResetScore: - s = "reset_score" - case PlayToClientPacketRespawn: - s = "respawn" - case PlayToClientPacketScoreboardDisplayObjective: - s = "scoreboard_display_objective" - case PlayToClientPacketScoreboardObjective: - s = "scoreboard_objective" - case PlayToClientPacketScoreboardScore: - s = "scoreboard_score" - case PlayToClientPacketSelectAdvancementTab: - s = "select_advancement_tab" - case PlayToClientPacketServerData: - s = "server_data" - case PlayToClientPacketSetCooldown: - s = "set_cooldown" - case PlayToClientPacketSetCursorItem: - s = "set_cursor_item" - case PlayToClientPacketSetPassengers: - s = "set_passengers" - case PlayToClientPacketSetPlayerInventory: - s = "set_player_inventory" - case PlayToClientPacketSetProjectilePower: - s = "set_projectile_power" - case PlayToClientPacketSetSlot: - s = "set_slot" - case PlayToClientPacketSetTickingState: - s = "set_ticking_state" - case PlayToClientPacketSetTitleSubtitle: - s = "set_title_subtitle" - case PlayToClientPacketSetTitleText: - s = "set_title_text" - case PlayToClientPacketSetTitleTime: - s = "set_title_time" - case PlayToClientPacketShowDialog: - s = "show_dialog" - case PlayToClientPacketSimulationDistance: - s = "simulation_distance" - case PlayToClientPacketSoundEffect: - s = "sound_effect" - case PlayToClientPacketSpawnEntity: - s = "spawn_entity" - case PlayToClientPacketSpawnPosition: - s = "spawn_position" - case PlayToClientPacketStartConfiguration: - s = "start_configuration" - case PlayToClientPacketStatistics: - s = "statistics" - case PlayToClientPacketStepTick: - s = "step_tick" - case PlayToClientPacketStopSound: - s = "stop_sound" - case PlayToClientPacketSyncEntityPosition: - s = "sync_entity_position" - case PlayToClientPacketSystemChat: - s = "system_chat" - case PlayToClientPacketTabComplete: - s = "tab_complete" - case PlayToClientPacketTags: - s = "tags" - case PlayToClientPacketTeams: - s = "teams" - case PlayToClientPacketTestInstanceBlockStatus: - s = "test_instance_block_status" - case PlayToClientPacketTileEntityData: - s = "tile_entity_data" - case PlayToClientPacketTrackedWaypoint: - s = "tracked_waypoint" - case PlayToClientPacketTradeList: - s = "trade_list" - case PlayToClientPacketUnloadChunk: - s = "unload_chunk" - case PlayToClientPacketUpdateHealth: - s = "update_health" - case PlayToClientPacketUpdateLight: - s = "update_light" - case PlayToClientPacketUpdateTime: - s = "update_time" - case PlayToClientPacketUpdateViewDistance: - s = "update_view_distance" - case PlayToClientPacketUpdateViewPosition: - s = "update_view_position" - case PlayToClientPacketVehicleMove: - s = "vehicle_move" - case PlayToClientPacketWindowItems: - s = "window_items" - case PlayToClientPacketWorldBorderCenter: - s = "world_border_center" - case PlayToClientPacketWorldBorderLerpSize: - s = "world_border_lerp_size" - case PlayToClientPacketWorldBorderSize: - s = "world_border_size" - case PlayToClientPacketWorldBorderWarningDelay: - s = "world_border_warning_delay" - case PlayToClientPacketWorldBorderWarningReach: - s = "world_border_warning_reach" - case PlayToClientPacketWorldEvent: - s = "world_event" - case PlayToClientPacketWorldParticles: - s = "world_particles" - case proto_base.Void: - s = "bundle_delimiter" - } - return -} - -func TypeToPacketIdentifier(d proto_base.Direction, s proto_base.State, t any) (i string) { - switch d { - case proto_base.ToServer: - switch s { - case proto_base.Handshaking: - i = HandshakingToServerTypeToPacketIdentifier(t) - case proto_base.Status: - i = StatusToServerTypeToPacketIdentifier(t) - case proto_base.Login: - i = LoginToServerTypeToPacketIdentifier(t) - case proto_base.Configuration: - i = ConfigurationToServerTypeToPacketIdentifier(t) - case proto_base.Play: - i = PlayToServerTypeToPacketIdentifier(t) - } - case proto_base.ToClient: - switch s { - case proto_base.Handshaking: - i = HandshakingToClientTypeToPacketIdentifier(t) - case proto_base.Status: - i = StatusToClientTypeToPacketIdentifier(t) - case proto_base.Login: - i = LoginToClientTypeToPacketIdentifier(t) - case proto_base.Configuration: - i = ConfigurationToClientTypeToPacketIdentifier(t) - case proto_base.Play: - i = PlayToClientTypeToPacketIdentifier(t) - } - } - return -} - -func PacketIdentifierToType(d proto_base.Direction, s proto_base.State, i string) (t any) { - switch d { - case proto_base.ToServer: - switch s { - case proto_base.Handshaking: - t = HandshakingToServerPacketIdentifierToType(i) - case proto_base.Status: - t = StatusToServerPacketIdentifierToType(i) - case proto_base.Login: - t = LoginToServerPacketIdentifierToType(i) - case proto_base.Configuration: - t = ConfigurationToServerPacketIdentifierToType(i) - case proto_base.Play: - t = PlayToServerPacketIdentifierToType(i) - } - case proto_base.ToClient: - switch s { - case proto_base.Handshaking: - t = HandshakingToClientPacketIdentifierToType(i) - case proto_base.Status: - t = StatusToClientPacketIdentifierToType(i) - case proto_base.Login: - t = LoginToClientPacketIdentifierToType(i) - case proto_base.Configuration: - t = ConfigurationToClientPacketIdentifierToType(i) - case proto_base.Play: - t = PlayToClientPacketIdentifierToType(i) - } - } - return -} - -func DecodePacket(d proto_base.Direction, s proto_base.State, r io.Reader) (params any, err error) { - switch d { - case proto_base.ToServer: - switch s { - case proto_base.Handshaking: - var packet HandshakingToServerPacket - packet, err = HandshakingToServerPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Status: - var packet StatusToServerPacket - packet, err = StatusToServerPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Login: - var packet LoginToServerPacket - packet, err = LoginToServerPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Configuration: - var packet ConfigurationToServerPacket - packet, err = ConfigurationToServerPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Play: - var packet PlayToServerPacket - packet, err = packet.Decode(r) - if err != nil { - return - } - params = packet.Params - } - case proto_base.ToClient: - switch s { - case proto_base.Handshaking: - var packet HandshakingToClientPacket - packet, err = HandshakingToClientPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Status: - var packet StatusToClientPacket - packet, err = StatusToClientPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Login: - var packet LoginToClientPacket - packet, err = LoginToClientPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Configuration: - var packet ConfigurationToClientPacket - packet, err = ConfigurationToClientPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Play: - var packet PlayToClientPacket - packet, err = PlayToClientPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - } - } - return -} - -func EncodePacket(d proto_base.Direction, s proto_base.State, i string, p any, w io.Writer) (err error) { - switch d { - case proto_base.ToServer: - switch s { - case proto_base.Handshaking: - err = HandshakingToServerPacket{i, p}.Encode(w) - case proto_base.Status: - err = StatusToServerPacket{i, p}.Encode(w) - case proto_base.Login: - err = LoginToServerPacket{i, p}.Encode(w) - case proto_base.Configuration: - err = ConfigurationToServerPacket{i, p}.Encode(w) - case proto_base.Play: - err = PlayToServerPacket{i, p}.Encode(w) - } - case proto_base.ToClient: - switch s { - case proto_base.Handshaking: - err = HandshakingToClientPacket{i, p}.Encode(w) - case proto_base.Status: - err = StatusToClientPacket{i, p}.Encode(w) - case proto_base.Login: - err = LoginToClientPacket{i, p}.Encode(w) - case proto_base.Configuration: - err = ConfigurationToClientPacket{i, p}.Encode(w) - case proto_base.Play: - err = PlayToClientPacket{i, p}.Encode(w) - } - } - return -} diff --git a/proto_generated/version_switcher.go b/proto_generated/version_switcher.go deleted file mode 100644 index 5f264ff..0000000 --- a/proto_generated/version_switcher.go +++ /dev/null @@ -1,37 +0,0 @@ -package proto_generated - -import ( - "github.com/admin-else/strom/proto_base" - "github.com/admin-else/strom/proto_generated/v1_21_8" - "io" -) - -func PacketIdentifierToType(v string, d proto_base.Direction, s proto_base.State, i string) (t any) { - switch v { - case "1.21.8": - t = v1_21_8.PacketIdentifierToType(d, s, i) - default: - } - return -} -func TypeToPacketIdentifier(v string, d proto_base.Direction, s proto_base.State, t any) (i string) { - switch v { - case "1.21.8": - i = v1_21_8.TypeToPacketIdentifier(d, s, t) - } - return -} -func DecodePacket(v string, d proto_base.Direction, s proto_base.State, r io.Reader) (packet any, err error) { - switch v { - case "1.21.8": - packet, err = v1_21_8.DecodePacket(d, s, r) - } - return -} -func EncodePacket(v string, d proto_base.Direction, s proto_base.State, i string, p any, w io.Writer) (err error) { - switch v { - case "1.21.8": - err = v1_21_8.EncodePacket(d, s, i, p, w) - } - return -} diff --git a/proto_generator/helper_append.txt b/proto_generator/helper_append.txt deleted file mode 100644 index b5a3deb..0000000 --- a/proto_generator/helper_append.txt +++ /dev/null @@ -1,178 +0,0 @@ - -func TypeToPacketIdentifier(d proto_base.Direction, s proto_base.State, t any) (i string) { - switch d { - case proto_base.ToServer: - switch s { - case proto_base.Handshaking: - i = HandshakingToServerTypeToPacketIdentifier(t) - case proto_base.Status: - i = StatusToServerTypeToPacketIdentifier(t) - case proto_base.Login: - i = LoginToServerTypeToPacketIdentifier(t) - case proto_base.Configuration: - i = ConfigurationToServerTypeToPacketIdentifier(t) - case proto_base.Play: - i = PlayToServerTypeToPacketIdentifier(t) - } - case proto_base.ToClient: - switch s { - case proto_base.Handshaking: - i = HandshakingToClientTypeToPacketIdentifier(t) - case proto_base.Status: - i = StatusToClientTypeToPacketIdentifier(t) - case proto_base.Login: - i = LoginToClientTypeToPacketIdentifier(t) - case proto_base.Configuration: - i = ConfigurationToClientTypeToPacketIdentifier(t) - case proto_base.Play: - i = PlayToClientTypeToPacketIdentifier(t) - } - } - return -} - -func PacketIdentifierToType(d proto_base.Direction, s proto_base.State, i string) (t any) { - switch d { - case proto_base.ToServer: - switch s { - case proto_base.Handshaking: - t = HandshakingToServerPacketIdentifierToType(i) - case proto_base.Status: - t = StatusToServerPacketIdentifierToType(i) - case proto_base.Login: - t = LoginToServerPacketIdentifierToType(i) - case proto_base.Configuration: - t = ConfigurationToServerPacketIdentifierToType(i) - case proto_base.Play: - t = PlayToServerPacketIdentifierToType(i) - } - case proto_base.ToClient: - switch s { - case proto_base.Handshaking: - t = HandshakingToClientPacketIdentifierToType(i) - case proto_base.Status: - t = StatusToClientPacketIdentifierToType(i) - case proto_base.Login: - t = LoginToClientPacketIdentifierToType(i) - case proto_base.Configuration: - t = ConfigurationToClientPacketIdentifierToType(i) - case proto_base.Play: - t = PlayToClientPacketIdentifierToType(i) - } - } - return -} - -func DecodePacket(d proto_base.Direction, s proto_base.State, r io.Reader) (params any, err error) { - switch d { - case proto_base.ToServer: - switch s { - case proto_base.Handshaking: - var packet HandshakingToServerPacket - packet, err = HandshakingToServerPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Status: - var packet StatusToServerPacket - packet, err = StatusToServerPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Login: - var packet LoginToServerPacket - packet, err = LoginToServerPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Configuration: - var packet ConfigurationToServerPacket - packet, err = ConfigurationToServerPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Play: - var packet PlayToServerPacket - packet, err = PlayToServerPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - } - case proto_base.ToClient: - switch s { - case proto_base.Handshaking: - var packet HandshakingToClientPacket - packet, err = HandshakingToClientPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Status: - var packet StatusToClientPacket - packet, err = StatusToClientPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Login: - var packet LoginToClientPacket - packet, err = LoginToClientPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Configuration: - var packet ConfigurationToClientPacket - packet, err = ConfigurationToClientPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - case proto_base.Play: - var packet PlayToClientPacket - packet, err = PlayToClientPacket{}.Decode(r) - if err != nil { - return - } - params = packet.Params - } - } - return -} - -func EncodePacket(d proto_base.Direction, s proto_base.State, i string, p any, w io.Writer) (err error) { - switch d { - case proto_base.ToServer: - switch s { - case proto_base.Handshaking: - err = HandshakingToServerPacket{i, p}.Encode(w) - case proto_base.Status: - err = StatusToServerPacket{i, p}.Encode(w) - case proto_base.Login: - err = LoginToServerPacket{i, p}.Encode(w) - case proto_base.Configuration: - err = ConfigurationToServerPacket{i, p}.Encode(w) - case proto_base.Play: - err = PlayToServerPacket{i, p}.Encode(w) - } - case proto_base.ToClient: - switch s { - case proto_base.Handshaking: - err = HandshakingToClientPacket{i, p}.Encode(w) - case proto_base.Status: - err = StatusToClientPacket{i, p}.Encode(w) - case proto_base.Login: - err = LoginToClientPacket{i, p}.Encode(w) - case proto_base.Configuration: - err = ConfigurationToClientPacket{i, p}.Encode(w) - case proto_base.Play: - err = PlayToClientPacket{i, p}.Encode(w) - } - } - return -} diff --git a/proto_generator/helper_generator.go b/proto_generator/helper_generator.go index 3ebf1b2..d3ce754 100644 --- a/proto_generator/helper_generator.go +++ b/proto_generator/helper_generator.go @@ -2,128 +2,128 @@ package main import ( "go/ast" - "io" + "os" + "strconv" "strings" - _ "embed" - "github.com/admin-else/strom/data" ) -//go:embed helper_append.txt -var helperAppend string +type TypesInfo struct { + Types + Direction string + State string +} -func GenerateHelperTypes(t Types, prefix string, f *ast.File) (err error) { - for k, v := range t.Types { - if k != "packet" { - continue +type PacketInfo struct { + TName, Name, Direction, State, PacketId, ProtocolVersion, MinecraftVersion string +} + +func CollectPacketInfo(versions []string) (packetInfos []PacketInfo, err error) { + var versionData data.ProtocolVersion + for _, version := range versions { + versionData, err = data.LookUpProtocolVersionByName(version) + if err != nil { + return } - v := v.([]any)[1].([]any)[1].(map[string]any)["type"].([]any)[1].(map[string]any)["fields"].(map[string]any) - m := make(map[string]string) - for k2, v2 := range v { - v2 := v2.(string) - if strings.HasPrefix(v2, "packet_common") { - m[k2] = CamelCase(v2) - } else if v2 == "void" { - m[k2] = "proto_base.Void" - } else { - m[k2] = prefix + CamelCase(v2) + protocol := Protocol{} + err = data.LoadVersionedJson(version, "protocol", &protocol) + if err != nil { + return + } + prefixTypeMap := map[string]TypesInfo{ + "HandshakingToServer": {protocol.Handshaking.ToServer, "ToServer", "Handshaking"}, + "HandshakingToClient": {protocol.Handshaking.ToClient, "ToClient", "Handshaking"}, + "StatusToServer": {protocol.Status.ToServer, "ToServer", "Status"}, + "StatusToClient": {protocol.Status.ToClient, "ToClient", "Status"}, + "LoginToServer": {protocol.Login.ToServer, "ToServer", "Login"}, + "LoginToClient": {protocol.Login.ToClient, "ToClient", "Login"}, + "ConfigurationToServer": {protocol.Configuration.ToServer, "ToServer", "Configuration"}, + "ConfigurationToClient": {protocol.Configuration.ToClient, "ToClient", "Configuration"}, + "PlayToServer": {protocol.Play.ToServer, "ToServer", "Play"}, + "PlayToClient": {protocol.Play.ToClient, "ToClient", "Play"}, + } + for prefix, types := range prefixTypeMap { + for k, v := range types.Types.Types { + if k != "packet" { + continue + } + packetIds := v.([]any)[1].([]any)[0].(map[string]any)["type"].([]any)[1].(map[string]any)["mappings"].(map[string]any) + packetIdsStrings := AssertAndConvertMapValues[string](packetIds) + packetIdsRev := ReverseMap(packetIdsStrings) + v := v.([]any)[1].([]any)[1].(map[string]any)["type"].([]any)[1].(map[string]any)["fields"].(map[string]any) + for k2, v2 := range v { + v2 := v2.(string) + var typeName string + if strings.HasPrefix(v2, "packet_common") { + typeName = CamelCase(v2) + } else if v2 == "void" { + typeName = "struct{}" + } else { + typeName = prefix + CamelCase(v2) + } + packetInfos = append(packetInfos, PacketInfo{ + TName: typeName, + Name: k2, + Direction: types.Direction, + State: types.State, + PacketId: packetIdsRev[k2], + ProtocolVersion: strconv.Itoa(versionData.Version), + MinecraftVersion: version, + }) + } } } - err = PacketIdentifierToTypeGenerator(prefix, f, m) - if err != nil { - return + } + return +} + +func GeneratePacketInfoFile(versions []string) (err error) { + var packetInfos []PacketInfo + packetInfos, err = CollectPacketInfo(versions) + if err != nil { + return + } + + f := NewFile("proto_generated") + imports := []string{"reflect", "github.com/admin-else/strom/proto_base"} + for _, v := range versions { + vUnderscore := strings.ReplaceAll(v, ".", "_") + imports = append(imports, "github.com/admin-else/strom/proto_generated/v"+vUnderscore) + } + AppendDecl(f, Import(imports...)) + + var packetInfoExprs []ast.Expr + for _, p := range packetInfos { + vUnderscore := "v" + strings.ReplaceAll(p.MinecraftVersion, ".", "_") + typeName := p.TName + var typeExpr ast.Expr + if typeName == "struct{}" { + typeExpr = &ast.StructType{Fields: &ast.FieldList{}} + } else if strings.HasPrefix(typeName, "proto_base.") { + typeExpr = Selector("proto_base", strings.TrimPrefix(typeName, "proto_base.")) + } else { + typeExpr = Selector(vUnderscore, typeName) } - m = ReverseMap(m) - err = TypeToPacketIdentifierGenerator(prefix, f, m) - if err != nil { - return - } - } - return -} -func GenerateHelperState(s State, prefix string, f *ast.File) (err error) { - err = GenerateHelperTypes(s.ToServer, prefix+"ToServer", f) - if err != nil { - return - } - return GenerateHelperTypes(s.ToClient, prefix+"ToClient", f) -} + packetId, _ := strconv.ParseInt(p.PacketId, 0, 32) + protocolVersion, _ := strconv.Atoi(p.ProtocolVersion) -func GenerateHelperProtocol(p Protocol, f *ast.File) (err error) { - err = GenerateHelperState(p.Handshaking, "Handshaking", f) + packetInfoExprs = append(packetInfoExprs, CompLit(Selector("proto_base", "PacketInfo"), []ast.Expr{ + KeyValueExpr(Ident("Type"), Call(Selector("reflect", "TypeOf"), CompLit(typeExpr, nil))), + KeyValueExpr(Ident("Name"), StrLit(p.Name)), + KeyValueExpr(Ident("Direction"), Selector("proto_base", p.Direction)), + KeyValueExpr(Ident("State"), Selector("proto_base", p.State)), + KeyValueExpr(Ident("PacketId"), NumLit(int(packetId))), + KeyValueExpr(Ident("ProtocolVersion"), NumLit(protocolVersion)), + })) + } + AppendDecl(f, VarValues("Packets", CompLit(Slice(Selector("proto_base", "PacketInfo")), packetInfoExprs))) + out, err := os.Create("proto_generated/packet_info.go") if err != nil { return } - err = GenerateHelperState(p.Status, "Status", f) - if err != nil { - return - } - err = GenerateHelperState(p.Login, "Login", f) - if err != nil { - return - } - err = GenerateHelperState(p.Configuration, "Configuration", f) - if err != nil { - return - } - err = GenerateHelperState(p.Play, "Play", f) - if err != nil { - return - } - return -} + defer out.Close() -// PacketIdentifierToTypeGenerator func PacketIdentifierToType(s string) any { -// switch s { -// case "abilities": -// return PlayToClientPacketAbilities{} -// default: -// return nil -// } -// } -func PacketIdentifierToTypeGenerator(funcNamePrefix string, f *ast.File, m map[string]string) (err error) { - var s []ast.Stmt - for _, k := range OrderedKeys(m) { - v := m[k] - s = append(s, Case(Exprs(StrLit(k)), Stmts(Assign121(Ident("t"), CompLit(Ident(v), nil))))) - } - s = append(s, Case(nil, Stmts(Assign121(Ident("t"), Nil())))) - fn := NewFunc(funcNamePrefix+"PacketIdentifierToType", []NameAndType{{"s", Ident("string")}}, []NameAndType{{"t", Ident("any")}}) - fn.Body = NewBlockEllipsis(SwitchStmt(Ident("s"), NewBlock(s)), Return()) - AppendDecl(f, fn) - return -} - -func TypeToPacketIdentifierGenerator(funcNamePrefix string, f *ast.File, m map[string]string) (err error) { - var s []ast.Stmt - for _, k := range OrderedKeys(m) { - v := m[k] - s = append(s, Case(Exprs(Ident(k)), Stmts(Assign121(Ident("s"), StrLit(v))))) - } - fn := NewFunc(funcNamePrefix+"TypeToPacketIdentifier", []NameAndType{{"t", Ident("any")}}, []NameAndType{{"s", Ident("string")}}) - fn.Body = NewBlockEllipsis(TypeSwitch(ExprStmt(TypeAssert(Ident("t"), Ident("type"))), NewBlock(s)), Return()) - AppendDecl(f, fn) - return -} - -func GenerateHelpers(version string, w io.Writer) (err error) { - protocol := Protocol{} - err = data.LoadVersionedJson(version, "protocol", &protocol) - if err != nil { - return - } - f := NewFile("v" + strings.ReplaceAll(version, ".", "_")) - AppendDecl(f, Import("io", "github.com/admin-else/strom/proto_base")) - err = GenerateHelperProtocol(protocol, f) - if err != nil { - return - } - err = PrintToFile(f, w) - if err != nil { - return - } - _, err = w.Write([]byte(helperAppend)) - return + return PrintToFile(f, out) } diff --git a/proto_generator/main.go b/proto_generator/main.go index 3895d56..4911f23 100644 --- a/proto_generator/main.go +++ b/proto_generator/main.go @@ -197,7 +197,7 @@ func FixPointerReceivers(e ast.Expr) (td ast.Expr, ret ast.Expr) { return } -func (g *Generator) GenerateTypes(prefix string, types Types) error { +func (g *Generator) GenerateTypes(prefix string, types Types) (err error) { g.CurrentlyGeneratingTypes = types g.CurrentlyGeneratingTypesPrefix = prefix for _, k := range OrderedKeys(types.Types) { @@ -207,13 +207,13 @@ func (g *Generator) GenerateTypes(prefix string, types Types) error { } g.Depth = 0 - e, err := g.VisitType(v) - if errors.Is(err, ToDoError) { + e, err2 := g.VisitType(v) + if errors.Is(err2, ToDoError) { e = Selector("proto_base", "ToDo") - err = nil + err2 = nil } - if err != nil { - return err + if err2 != nil { + return err2 } if e == nil { // This is for types we implement ourselves continue @@ -229,11 +229,11 @@ func (g *Generator) GenerateTypes(prefix string, types Types) error { rets := []NameAndType{{"err", Ident("error")}} decodeFunction := NewFuncWithReceiver("Decode", "ret", Pointer(Ident(tName)), args, rets) g.Depth = 0 - s, err := g.VisitDecoder(retExpr, v, tName) - if err != nil { + s, err2 := g.VisitDecoder(retExpr, v, tName) + if err2 != nil { s = ToDoStmts - if !errors.Is(err, ToDoError) { - fmt.Println("failed to make decoder for", k, err) + if !errors.Is(err2, ToDoError) { + fmt.Println("failed to make decoder for", k, err2) } } decodeFunction.Body = NewBlock(append(s, Return())) @@ -243,18 +243,18 @@ func (g *Generator) GenerateTypes(prefix string, types Types) error { rets = []NameAndType{{"err", Ident("error")}} encodeFunction := NewFuncWithReceiver("Encode", "ret", Pointer(Ident(tName)), args, rets) g.Depth = 0 - s, err = g.VisitEncoder(retExpr, v, tName) - if err != nil { + s, err2 = g.VisitEncoder(retExpr, v, tName) + if err2 != nil { s = ToDoStmts - if !errors.Is(err, ToDoError) { - fmt.Println("failed to make encoder for", k, err) + if !errors.Is(err2, ToDoError) { + fmt.Println("failed to make encoder for", k, err2) } } encodeFunction.Body = NewBlock(append(s, Return())) AppendDecl(g.File, encodeFunction) } - return nil + return } func (g *Generator) GenerateState(prefix string, state State) (err error) { @@ -331,12 +331,6 @@ func generateVersion(v string) (err error) { if err != nil { return } - helperF, err := os.Create("proto_generated/v" + vUnderscore + "/helpers.go") - if err != nil { - return - } - defer f.Close() - err = GenerateHelpers(v, helperF) return } @@ -349,12 +343,6 @@ func GenerateVersions(versions []string) (err error) { if err != nil { return } - f, err := os.Create("proto_generated/version_switcher.go") - if err != nil { - return - } - defer f.Close() - err = GenerateVersionSwitcher(versions, f) for _, version := range versions { fmt.Println("generating", version) err = generateVersion(version) @@ -362,7 +350,7 @@ func GenerateVersions(versions []string) (err error) { return } } - return + return GeneratePacketInfoFile(versions) } func main() { diff --git a/proto_generator/printer.go b/proto_generator/printer.go index 32e533d..d4c7466 100644 --- a/proto_generator/printer.go +++ b/proto_generator/printer.go @@ -8,13 +8,12 @@ import ( "io" ) -func NewStruct() *ast.StructType { +func NewStruct() (s *ast.StructType) { return &ast.StructType{ Fields: &ast.FieldList{ List: []*ast.Field{}, }, } - } func AddFieldToStruct(s *ast.StructType, fieldName string, t ast.Expr) { @@ -48,7 +47,7 @@ func Import(path ...string) ast.Decl { } } -func Ident(name string) *ast.Ident { +func Ident(name string) (id *ast.Ident) { return ast.NewIdent(name) } @@ -56,6 +55,18 @@ func VarStmt(name string, t ast.Expr) *ast.DeclStmt { return &ast.DeclStmt{Decl: Var(name, t)} } +func VarValues(name string, v ...ast.Expr) ast.Decl { + return &ast.GenDecl{ + Tok: token.VAR, + Specs: []ast.Spec{ + &ast.ValueSpec{ + Names: []*ast.Ident{Ident(name)}, + Values: v, + }, + }, + } +} + func Var(name string, t ast.Expr) ast.Decl { return &ast.GenDecl{ Tok: token.VAR, @@ -72,7 +83,7 @@ func Var(name string, t ast.Expr) ast.Decl { } } -func Slice(elementType ast.Expr) ast.Expr { +func Slice(elementType ast.Expr) (e ast.Expr) { return &ast.ArrayType{ Len: nil, // nil Length means it's a slice, not an array Elt: elementType, @@ -116,34 +127,34 @@ func TypeDecl(name string, t ast.Expr) ast.Decl { } } -func Selector(x, sel string) ast.Expr { +func Selector(x, sel string) (e ast.Expr) { return &ast.SelectorExpr{ X: Ident(x), Sel: Ident(sel), } } -func SelectorExprAndStr(x ast.Expr, sel string) ast.Expr { +func SelectorExprAndStr(x ast.Expr, sel string) (e ast.Expr) { return &ast.SelectorExpr{ X: x, Sel: Ident(sel), } } -func Pointer(elementType ast.Expr) ast.Expr { +func Pointer(elementType ast.Expr) (e ast.Expr) { return &ast.StarExpr{ X: elementType, } } -func Call(fn ast.Expr, args ...ast.Expr) *ast.CallExpr { +func Call(fn ast.Expr, args ...ast.Expr) (e *ast.CallExpr) { return &ast.CallExpr{ Fun: fn, Args: args, } } -func Assign121(lhs, rhs ast.Expr) *ast.AssignStmt { +func Assign121(lhs, rhs ast.Expr) (s *ast.AssignStmt) { return &ast.AssignStmt{ Lhs: []ast.Expr{lhs}, Tok: token.ASSIGN, @@ -151,7 +162,7 @@ func Assign121(lhs, rhs ast.Expr) *ast.AssignStmt { } } -func Assign(lhs, rhs []ast.Expr) *ast.AssignStmt { +func Assign(lhs, rhs []ast.Expr) (s *ast.AssignStmt) { return &ast.AssignStmt{ Lhs: lhs, Tok: token.ASSIGN, @@ -159,7 +170,7 @@ func Assign(lhs, rhs []ast.Expr) *ast.AssignStmt { } } -func Define(lhs, rhs []ast.Expr) *ast.AssignStmt { +func Define(lhs, rhs []ast.Expr) (s *ast.AssignStmt) { return &ast.AssignStmt{ Lhs: lhs, Tok: token.DEFINE, @@ -167,7 +178,7 @@ func Define(lhs, rhs []ast.Expr) *ast.AssignStmt { } } -func Define121(lhs, rhs ast.Expr) *ast.AssignStmt { +func Define121(lhs, rhs ast.Expr) (s *ast.AssignStmt) { return &ast.AssignStmt{ Lhs: []ast.Expr{lhs}, Tok: token.DEFINE, diff --git a/proto_generator/utils.go b/proto_generator/utils.go index c1b758f..7c0c408 100644 --- a/proto_generator/utils.go +++ b/proto_generator/utils.go @@ -9,7 +9,8 @@ import ( var boundaries = []rune{' ', '_', '-', '.', ',', ';', ':', '(', ')', '[', ']', '{', '}'} -func CamelCase(s string) (ret string) { +func CamelCase(s string) string { + ret := "" atWordBoundary := true for _, c := range s { if slices.Contains(boundaries, c) { @@ -22,7 +23,7 @@ func CamelCase(s string) (ret string) { atWordBoundary = false ret += string(c) } - return + return ret } func OrderedKeys[Map map[K]V, K cmp.Ordered, V any](m Map) []K { @@ -32,12 +33,20 @@ func OrderedKeys[Map map[K]V, K cmp.Ordered, V any](m Map) []K { return keys } -func ReverseMap[M map[K]V, K cmp.Ordered, V cmp.Ordered](m M) (ret map[V]K) { - ret = map[V]K{} +func AssertAndConvertMapValues[T any, M map[K]any, K cmp.Ordered](m M) map[K]T { + ret := map[K]T{} + for k, v := range m { + ret[k] = v.(T) + } + return ret +} + +func ReverseMap[M map[K]V, K cmp.Ordered, V cmp.Ordered](m M) map[V]K { + ret := map[V]K{} for k, v := range m { ret[v] = k } - return + return ret } func must(err error) { @@ -46,9 +55,10 @@ func must(err error) { } } -func PopFront[T any](s []T) (front T, rest []T, ok bool) { +func PopFront[T any](s []T) (T, []T, bool) { if len(s) == 0 { - return front, s, false + var zero T + return zero, s, false } return s[0], s[1:], true } diff --git a/proto_generator/version_swticher.go b/proto_generator/version_swticher.go deleted file mode 100644 index 5c3c86a..0000000 --- a/proto_generator/version_swticher.go +++ /dev/null @@ -1,143 +0,0 @@ -package main - -import ( - "go/ast" - "io" - "strings" -) - -func GeneratePacketIdentifierToType(versions []string) (decl ast.Decl) { - var s []ast.Stmt - for _, version := range versions { - s = append(s, Case(Exprs(StrLit(version)), Stmts( - Assign121(Ident("t"), Call(SelectorExprAndStr(Ident("v"+strings.ReplaceAll(version, ".", "_")), "PacketIdentifierToType"), Ident("d"), Ident("s"), Ident("i"))), - ))) - } - s = append(s, Case(nil, Stmts())) - fn := NewFunc("PacketIdentifierToType", []NameAndType{ - {"v", Ident("string")}, - {"d", Ident("proto_base.Direction")}, - {"s", Ident("proto_base.State")}, - {"i", Ident("string")}, - }, []NameAndType{ - {"t", Ident("any")}, - }) - fn.Body = NewBlockEllipsis(SwitchStmt(Ident("v"), NewBlock(s)), Return()) - decl = fn - return -} - -/* -func PacketIdentifierToType(v string, d proto_base.Direction, s proto_base.State, i string) (t any) { - switch v { - case "1.21.8": - t = v1_21_8.PacketIdentifierToType(d, s, i) - default: - - } - return -} - -func TypeToPacketIdentifier(v string, d proto_base.Direction, s proto_base.State, t any) (i string) { - switch v { - case "1.21.8": - i = v1_21_8.TypeToPacketIdentifier(d, s, t) - } - return -} - -func DecodePacket(v string, d proto_base.Direction, s proto_base.State, r io.Reader) (packet any, err error) { - switch v { - case "1.21.8": - packet, err = v1_21_8.DecodePacket(d, s, r) - } - return -} - -func EncodePacket(v string, d proto_base.Direction, s proto_base.State, i string, p any, w io.Writer) (err error) { - switch v { - case "1.21.8": - err = v1_21_8.EncodePacket(d, s, i, p, w) - - } - return -} - -*/ - -func GenerateTypeToPacketIdentifier(versions []string) (decl ast.Decl) { - var s []ast.Stmt - for _, version := range versions { - s = append(s, Case(Exprs(StrLit(version)), Stmts( - Assign121(Ident("i"), Call(SelectorExprAndStr(Ident("v"+strings.ReplaceAll(version, ".", "_")), "TypeToPacketIdentifier"), Ident("d"), Ident("s"), Ident("t"))), - ))) - } - fn := NewFunc("TypeToPacketIdentifier", []NameAndType{ - {"v", Ident("string")}, - {"d", Ident("proto_base.Direction")}, - {"s", Ident("proto_base.State")}, - {"t", Ident("any")}, - }, []NameAndType{ - {"i", Ident("string")}, - }) - fn.Body = NewBlockEllipsis(SwitchStmt(Ident("v"), NewBlock(s)), Return()) - decl = fn - return -} - -func GenerateDecodePacket(versions []string) (decl ast.Decl) { - var s []ast.Stmt - for _, version := range versions { - s = append(s, Case(Exprs(StrLit(version)), Stmts( - Assign([]ast.Expr{Ident("packet"), Ident("err")}, []ast.Expr{Call(SelectorExprAndStr(Ident("v"+strings.ReplaceAll(version, ".", "_")), "DecodePacket"), Ident("d"), Ident("s"), Ident("r"))}), - ))) - } - fn := NewFunc("DecodePacket", []NameAndType{ - {"v", Ident("string")}, - {"d", Ident("proto_base.Direction")}, - {"s", Ident("proto_base.State")}, - {"r", Ident("io.Reader")}, - }, []NameAndType{ - {"packet", Ident("any")}, - {"err", Ident("error")}, - }) - fn.Body = NewBlockEllipsis(SwitchStmt(Ident("v"), NewBlock(s)), Return()) - decl = fn - return -} - -func GenerateEncodePacket(versions []string) (decl ast.Decl) { - var s []ast.Stmt - for _, version := range versions { - s = append(s, Case(Exprs(StrLit(version)), Stmts( - Assign121(Ident("err"), Call(SelectorExprAndStr(Ident("v"+strings.ReplaceAll(version, ".", "_")), "EncodePacket"), Ident("d"), Ident("s"), Ident("i"), Ident("p"), Ident("w"))), - ))) - } - fn := NewFunc("EncodePacket", []NameAndType{ - {"v", Ident("string")}, - {"d", Ident("proto_base.Direction")}, - {"s", Ident("proto_base.State")}, - {"i", Ident("string")}, - {"p", Ident("any")}, - {"w", Ident("io.Writer")}, - }, []NameAndType{ - {"err", Ident("error")}, - }) - fn.Body = NewBlockEllipsis(SwitchStmt(Ident("v"), NewBlock(s)), Return()) - decl = fn - return -} - -func GenerateVersionSwitcher(versions []string, printTo io.Writer) (err error) { - f := NewFile("proto_generated") - importPaths := []string{"io", "github.com/admin-else/strom/proto_base"} - for _, version := range versions { - importPaths = append(importPaths, "github.com/admin-else/strom/proto_generated/v"+strings.ReplaceAll(version, ".", "_")) - } - AppendDecl(f, Import(importPaths...)) - AppendDecl(f, GeneratePacketIdentifierToType(versions)) - AppendDecl(f, GenerateTypeToPacketIdentifier(versions)) - AppendDecl(f, GenerateDecodePacket(versions)) - AppendDecl(f, GenerateEncodePacket(versions)) - return PrintToFile(f, printTo) -}