From 0034a2c6d44ea00566448d4bab94c9ad4ab26409 Mon Sep 17 00:00:00 2001 From: adman Date: Sun, 18 Jan 2026 17:12:02 +0100 Subject: [PATCH] we do ship the generated code now --- .gitignore | 1 - proto_generated/packet_info.go | 8 + proto_generated/v1_21_8/proto.go | 28143 +++++++++++++++++++++++++++++ 3 files changed, 28151 insertions(+), 1 deletion(-) create mode 100644 proto_generated/packet_info.go create mode 100644 proto_generated/v1_21_8/proto.go diff --git a/.gitignore b/.gitignore index 77120a5..e9ffc91 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,3 @@ .devres/ .idea/ .failed_packets/ -proto_generated/* \ No newline at end of file diff --git a/proto_generated/packet_info.go b/proto_generated/packet_info.go new file mode 100644 index 0000000..e98998a --- /dev/null +++ b/proto_generated/packet_info.go @@ -0,0 +1,8 @@ +package proto_generated + +import ( + "github.com/admin-else/strom/proto_base" + "github.com/admin-else/strom/proto_generated/v1_21_8" +) + +var Packets = []proto_base.PacketInfo{{Type: &v1_21_8.LoginToClientPacketDisconnect{}, Name: "disconnect", Direction: proto_base.ToClient, State: proto_base.Login, PacketId: 0, ProtocolVersion: 772}, {Type: &v1_21_8.LoginToClientPacketEncryptionBegin{}, Name: "encryption_begin", Direction: proto_base.ToClient, State: proto_base.Login, PacketId: 1, ProtocolVersion: 772}, {Type: &v1_21_8.LoginToClientPacketSuccess{}, Name: "success", Direction: proto_base.ToClient, State: proto_base.Login, PacketId: 2, ProtocolVersion: 772}, {Type: &v1_21_8.LoginToClientPacketCompress{}, Name: "compress", Direction: proto_base.ToClient, State: proto_base.Login, PacketId: 3, ProtocolVersion: 772}, {Type: &v1_21_8.LoginToClientPacketLoginPluginRequest{}, Name: "login_plugin_request", Direction: proto_base.ToClient, State: proto_base.Login, PacketId: 4, ProtocolVersion: 772}, {Type: &v1_21_8.LoginToClientPacketCommonCookieRequest{}, Name: "cookie_request", Direction: proto_base.ToClient, State: proto_base.Login, PacketId: 5, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToServerPacketCustomPayload{}, Name: "custom_payload", Direction: proto_base.ToServer, State: proto_base.Configuration, PacketId: 2, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToServerPacketResourcePackReceive{}, Name: "resource_pack_receive", Direction: proto_base.ToServer, State: proto_base.Configuration, PacketId: 6, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToServerPacketCommonSelectKnownPacks{}, Name: "select_known_packs", Direction: proto_base.ToServer, State: proto_base.Configuration, PacketId: 7, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToServerPacketCommonCustomClickAction{}, Name: "custom_click_action", Direction: proto_base.ToServer, State: proto_base.Configuration, PacketId: 8, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToServerPacketCommonSettings{}, Name: "settings", Direction: proto_base.ToServer, State: proto_base.Configuration, PacketId: 0, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToServerPacketCommonCookieResponse{}, Name: "cookie_response", Direction: proto_base.ToServer, State: proto_base.Configuration, PacketId: 1, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToServerPacketFinishConfiguration{}, Name: "finish_configuration", Direction: proto_base.ToServer, State: proto_base.Configuration, PacketId: 3, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToServerPacketKeepAlive{}, Name: "keep_alive", Direction: proto_base.ToServer, State: proto_base.Configuration, PacketId: 4, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToServerPacketPong{}, Name: "pong", Direction: proto_base.ToServer, State: proto_base.Configuration, PacketId: 5, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketCustomPayload{}, Name: "custom_payload", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 1, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketFinishConfiguration{}, Name: "finish_configuration", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 3, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketCommonAddResourcePack{}, Name: "add_resource_pack", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 9, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketCommonSelectKnownPacks{}, Name: "select_known_packs", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 14, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketRegistryData{}, Name: "registry_data", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 7, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketTags{}, Name: "tags", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 13, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketCommonCustomReportDetails{}, Name: "custom_report_details", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 15, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketCommonClearDialog{}, Name: "clear_dialog", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 17, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketShowDialog{}, Name: "show_dialog", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 18, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketCommonCookieRequest{}, Name: "cookie_request", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 0, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketPing{}, Name: "ping", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 5, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketResetChat{}, Name: "reset_chat", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 6, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketCommonRemoveResourcePack{}, Name: "remove_resource_pack", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 8, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketCommonServerLinks{}, Name: "server_links", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 16, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketDisconnect{}, Name: "disconnect", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 2, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketKeepAlive{}, Name: "keep_alive", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 4, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketCommonStoreCookie{}, Name: "store_cookie", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 10, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketCommonTransfer{}, Name: "transfer", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 11, ProtocolVersion: 772}, {Type: &v1_21_8.ConfigurationToClientPacketFeatureFlags{}, Name: "feature_flags", Direction: proto_base.ToClient, State: proto_base.Configuration, PacketId: 12, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCommonAddResourcePack{}, Name: "add_resource_pack", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 74, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketStepTick{}, Name: "step_tick", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 121, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketPlayerRemove{}, Name: "player_remove", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 62, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketPlayerInfo{}, Name: "player_info", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 63, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketRecipeBookRemove{}, Name: "recipe_book_remove", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 68, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSpawnEntity{}, Name: "spawn_entity", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 1, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketBlockChange{}, Name: "block_change", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 8, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketOpenBook{}, Name: "open_book", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 51, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketActionBar{}, Name: "action_bar", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 80, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketPing{}, Name: "ping", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 54, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketRecipeBookSettings{}, Name: "recipe_book_settings", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 69, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityTeleport{}, Name: "entity_teleport", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 118, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketChunkBiomes{}, Name: "chunk_biomes", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 13, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketDebugSample{}, Name: "debug_sample", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 26, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketProfilelessChat{}, Name: "profileless_chat", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 29, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketWorldBorderWarningReach{}, Name: "world_border_warning_reach", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 85, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketKeepAlive{}, Name: "keep_alive", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 38, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketRemoveEntityEffect{}, Name: "remove_entity_effect", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 71, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketUpdateHealth{}, Name: "update_health", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 97, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityLook{}, Name: "entity_look", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 49, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCraftRecipeResponse{}, Name: "craft_recipe_response", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 56, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketServerData{}, Name: "server_data", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 79, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketAdvancements{}, Name: "advancements", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 123, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCommonServerLinks{}, Name: "server_links", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 130, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketChunkBatchStart{}, Name: "chunk_batch_start", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 12, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketMoveMinecart{}, Name: "move_minecart", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 48, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketPlayerChat{}, Name: "player_chat", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 58, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSetTitleText{}, Name: "set_title_text", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 107, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCollect{}, Name: "collect", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 117, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityHeadRotation{}, Name: "entity_head_rotation", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 76, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCommonCustomReportDetails{}, Name: "custom_report_details", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 129, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketBossBar{}, Name: "boss_bar", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 9, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketGameStateChange{}, Name: "game_state_change", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 34, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketHurtAnimation{}, Name: "hurt_animation", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 36, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketRespawn{}, Name: "respawn", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 75, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSetTickingState{}, Name: "set_ticking_state", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 120, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketClearTitles{}, Name: "clear_titles", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 14, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketChatSuggestions{}, Name: "chat_suggestions", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 23, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketPosition{}, Name: "position", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 65, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketWorldBorderCenter{}, Name: "world_border_center", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 81, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketUpdateTime{}, Name: "update_time", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 106, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSoundEffect{}, Name: "sound_effect", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 110, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketBundleDelimiter{}, Name: "bundle_delimiter", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 0, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketWorldEvent{}, Name: "world_event", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 40, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketDeathCombatEvent{}, Name: "death_combat_event", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 61, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketExperience{}, Name: "experience", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 96, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSetCooldown{}, Name: "set_cooldown", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 22, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketTradeList{}, Name: "trade_list", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 45, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityUpdateAttributes{}, Name: "entity_update_attributes", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 124, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketDeclareCommands{}, Name: "declare_commands", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 16, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCloseWindow{}, Name: "close_window", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 17, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketMapChunk{}, Name: "map_chunk", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 39, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketMap{}, Name: "map", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 44, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketHeldItemSlot{}, Name: "held_item_slot", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 98, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketDifficulty{}, Name: "difficulty", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 10, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketLogin{}, Name: "login", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 43, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketScoreboardScore{}, Name: "scoreboard_score", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 103, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCustomPayload{}, Name: "custom_payload", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 24, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketUpdateLight{}, Name: "update_light", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 42, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketResetScore{}, Name: "reset_score", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 72, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSelectAdvancementTab{}, Name: "select_advancement_tab", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 78, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSetPlayerInventory{}, Name: "set_player_inventory", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 101, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketUnloadChunk{}, Name: "unload_chunk", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 33, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketRelEntityMove{}, Name: "rel_entity_move", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 46, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketVehicleMove{}, Name: "vehicle_move", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 50, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSetPassengers{}, Name: "set_passengers", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 100, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSystemChat{}, Name: "system_chat", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 114, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketOpenHorseWindow{}, Name: "open_horse_window", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 35, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketOpenWindow{}, Name: "open_window", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 52, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketPingResponse{}, Name: "ping_response", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 55, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketDamageEvent{}, Name: "damage_event", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 25, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketInitializeWorldBorder{}, Name: "initialize_world_border", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 37, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSetCursorItem{}, Name: "set_cursor_item", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 89, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSpawnPosition{}, Name: "spawn_position", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 90, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSetTitleTime{}, Name: "set_title_time", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 108, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketPlayerlistHeader{}, Name: "playerlist_header", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 115, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCraftProgressBar{}, Name: "craft_progress_bar", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 19, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEndCombatEvent{}, Name: "end_combat_event", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 59, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityVelocity{}, Name: "entity_velocity", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 94, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCommonStoreCookie{}, Name: "store_cookie", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 113, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketTabComplete{}, Name: "tab_complete", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 15, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSetSlot{}, Name: "set_slot", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 20, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketFacePlayer{}, Name: "face_player", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 64, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketMultiBlockChange{}, Name: "multi_block_change", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 77, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCamera{}, Name: "camera", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 86, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketScoreboardObjective{}, Name: "scoreboard_objective", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 99, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSetTitleSubtitle{}, Name: "set_title_subtitle", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 105, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketAnimation{}, Name: "animation", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 2, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketBlockBreakAnimation{}, Name: "block_break_animation", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 5, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketWorldBorderSize{}, Name: "world_border_size", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 83, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityEffect{}, Name: "entity_effect", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 125, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketTrackedWaypoint{}, Name: "tracked_waypoint", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 131, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSyncEntityPosition{}, Name: "sync_entity_position", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 31, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketRecipeBookAdd{}, Name: "recipe_book_add", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 67, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketWorldBorderWarningDelay{}, Name: "world_border_warning_delay", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 84, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketAttachEntity{}, Name: "attach_entity", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 93, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSimulationDistance{}, Name: "simulation_distance", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 104, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketTags{}, Name: "tags", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 127, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketStatistics{}, Name: "statistics", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 3, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketTileEntityData{}, Name: "tile_entity_data", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 6, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketChunkBatchFinished{}, Name: "chunk_batch_finished", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 11, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketKickDisconnect{}, Name: "kick_disconnect", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 28, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketTestInstanceBlockStatus{}, Name: "test_instance_block_status", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 119, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCommonClearDialog{}, Name: "clear_dialog", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 132, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEnterCombatEvent{}, Name: "enter_combat_event", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 60, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCommonRemoveResourcePack{}, Name: "remove_resource_pack", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 73, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketWindowItems{}, Name: "window_items", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 18, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCommonCookieRequest{}, Name: "cookie_request", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 21, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketPlayerRotation{}, Name: "player_rotation", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 66, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketUpdateViewPosition{}, Name: "update_view_position", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 87, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketStopSound{}, Name: "stop_sound", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 112, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketCommonTransfer{}, Name: "transfer", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 122, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketShowDialog{}, Name: "show_dialog", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 133, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketUpdateViewDistance{}, Name: "update_view_distance", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 88, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketTeams{}, Name: "teams", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 102, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketNbtQueryResponse{}, Name: "nbt_query_response", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 116, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityMoveLook{}, Name: "entity_move_look", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 47, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketOpenSignEntity{}, Name: "open_sign_entity", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 53, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketAcknowledgePlayerDigging{}, Name: "acknowledge_player_digging", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 4, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityDestroy{}, Name: "entity_destroy", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 70, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketWorldBorderLerpSize{}, Name: "world_border_lerp_size", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 82, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketScoreboardDisplayObjective{}, Name: "scoreboard_display_objective", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 91, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityMetadata{}, Name: "entity_metadata", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 92, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketDeclareRecipes{}, Name: "declare_recipes", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 126, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketExplosion{}, Name: "explosion", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 32, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketSetProjectilePower{}, Name: "set_projectile_power", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 128, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntitySoundEffect{}, Name: "entity_sound_effect", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 109, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketStartConfiguration{}, Name: "start_configuration", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 111, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketBlockAction{}, Name: "block_action", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 7, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketHideMessage{}, Name: "hide_message", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 27, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketAbilities{}, Name: "abilities", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 57, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityEquipment{}, Name: "entity_equipment", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 95, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketEntityStatus{}, Name: "entity_status", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 30, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToClientPacketWorldParticles{}, Name: "world_particles", Direction: proto_base.ToClient, State: proto_base.Play, PacketId: 41, ProtocolVersion: 772}, {Type: &v1_21_8.HandshakingToServerPacketSetProtocol{}, Name: "set_protocol", Direction: proto_base.ToServer, State: proto_base.Handshaking, PacketId: 0, ProtocolVersion: 772}, {Type: &v1_21_8.HandshakingToServerPacketLegacyServerListPing{}, Name: "legacy_server_list_ping", Direction: proto_base.ToServer, State: proto_base.Handshaking, PacketId: 254, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketEnchantItem{}, Name: "enchant_item", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 16, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketQueryBlockNbt{}, Name: "query_block_nbt", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 1, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketChatSessionUpdate{}, Name: "chat_session_update", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 9, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketChunkBatchReceived{}, Name: "chunk_batch_received", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 10, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketQueryEntityNbt{}, Name: "query_entity_nbt", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 24, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketFlying{}, Name: "flying", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 32, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketVehicleMove{}, Name: "vehicle_move", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 33, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketPong{}, Name: "pong", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 44, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketUpdateJigsawBlock{}, Name: "update_jigsaw_block", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 56, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketTeleportConfirm{}, Name: "teleport_confirm", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 0, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketCustomPayload{}, Name: "custom_payload", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 21, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketEditBook{}, Name: "edit_book", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 23, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketSetTestBlock{}, Name: "set_test_block", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 58, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketUpdateSign{}, Name: "update_sign", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 59, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketArmAnimation{}, Name: "arm_animation", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 60, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketUseItem{}, Name: "use_item", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 64, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketSelectTrade{}, Name: "select_trade", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 50, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketTickEnd{}, Name: "tick_end", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 12, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketGenerateStructure{}, Name: "generate_structure", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 26, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketPositionLook{}, Name: "position_look", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 30, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketBlockDig{}, Name: "block_dig", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 40, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketSelectBundleItem{}, Name: "select_bundle_item", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 2, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketMessageAcknowledgement{}, Name: "message_acknowledgement", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 5, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketUseEntity{}, Name: "use_entity", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 25, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketChangeGamemode{}, Name: "change_gamemode", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 4, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketLook{}, Name: "look", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 31, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketPingRequest{}, Name: "ping_request", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 37, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketSpectate{}, Name: "spectate", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 61, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketClientCommand{}, Name: "client_command", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 11, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketConfigurationAcknowledged{}, Name: "configuration_acknowledged", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 15, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketCommonCookieResponse{}, Name: "cookie_response", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 20, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketEntityAction{}, Name: "entity_action", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 41, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketCommonCustomClickAction{}, Name: "custom_click_action", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 65, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketSetDifficulty{}, Name: "set_difficulty", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 3, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketDisplayedRecipe{}, Name: "displayed_recipe", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 46, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketHeldItemSlot{}, Name: "held_item_slot", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 52, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketSetCreativeSlot{}, Name: "set_creative_slot", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 55, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketChatCommandSigned{}, Name: "chat_command_signed", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 7, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketWindowClick{}, Name: "window_click", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 17, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketDebugSampleSubscription{}, Name: "debug_sample_subscription", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 22, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketSteerBoat{}, Name: "steer_boat", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 34, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketPickItemFromBlock{}, Name: "pick_item_from_block", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 35, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketPlayerInput{}, Name: "player_input", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 42, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketKeepAlive{}, Name: "keep_alive", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 27, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketAdvancementTab{}, Name: "advancement_tab", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 49, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketTestInstanceBlockAction{}, Name: "test_instance_block_action", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 62, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketSetSlotState{}, Name: "set_slot_state", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 19, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketLockDifficulty{}, Name: "lock_difficulty", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 28, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketAbilities{}, Name: "abilities", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 39, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketPlayerLoaded{}, Name: "player_loaded", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 43, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketRecipeBook{}, Name: "recipe_book", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 45, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketResourcePackReceive{}, Name: "resource_pack_receive", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 48, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketUpdateCommandBlock{}, Name: "update_command_block", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 53, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketCloseWindow{}, Name: "close_window", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 18, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketPickItemFromEntity{}, Name: "pick_item_from_entity", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 36, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketCraftRecipeRequest{}, Name: "craft_recipe_request", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 38, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketUpdateStructureBlock{}, Name: "update_structure_block", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 57, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketSetBeaconEffect{}, Name: "set_beacon_effect", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 51, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketChatCommand{}, Name: "chat_command", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 6, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketChatMessage{}, Name: "chat_message", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 8, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketPosition{}, Name: "position", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 29, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketNameItem{}, Name: "name_item", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 47, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketUpdateCommandBlockMinecart{}, Name: "update_command_block_minecart", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 54, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketBlockPlace{}, Name: "block_place", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 63, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketCommonSettings{}, Name: "settings", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 13, ProtocolVersion: 772}, {Type: &v1_21_8.PlayToServerPacketTabComplete{}, Name: "tab_complete", Direction: proto_base.ToServer, State: proto_base.Play, PacketId: 14, ProtocolVersion: 772}, {Type: &v1_21_8.StatusToServerPacketPingStart{}, Name: "ping_start", Direction: proto_base.ToServer, State: proto_base.Status, PacketId: 0, ProtocolVersion: 772}, {Type: &v1_21_8.StatusToServerPacketPing{}, Name: "ping", Direction: proto_base.ToServer, State: proto_base.Status, PacketId: 1, ProtocolVersion: 772}, {Type: &v1_21_8.StatusToClientPacketServerInfo{}, Name: "server_info", Direction: proto_base.ToClient, State: proto_base.Status, PacketId: 0, ProtocolVersion: 772}, {Type: &v1_21_8.StatusToClientPacketPing{}, Name: "ping", Direction: proto_base.ToClient, State: proto_base.Status, PacketId: 1, ProtocolVersion: 772}, {Type: &v1_21_8.LoginToServerPacketCommonCookieResponse{}, Name: "cookie_response", Direction: proto_base.ToServer, State: proto_base.Login, PacketId: 4, ProtocolVersion: 772}, {Type: &v1_21_8.LoginToServerPacketLoginStart{}, Name: "login_start", Direction: proto_base.ToServer, State: proto_base.Login, PacketId: 0, ProtocolVersion: 772}, {Type: &v1_21_8.LoginToServerPacketEncryptionBegin{}, Name: "encryption_begin", Direction: proto_base.ToServer, State: proto_base.Login, PacketId: 1, ProtocolVersion: 772}, {Type: &v1_21_8.LoginToServerPacketLoginPluginResponse{}, Name: "login_plugin_response", Direction: proto_base.ToServer, State: proto_base.Login, PacketId: 2, ProtocolVersion: 772}, {Type: &v1_21_8.LoginToServerPacketLoginAcknowledged{}, Name: "login_acknowledged", Direction: proto_base.ToServer, State: proto_base.Login, PacketId: 3, ProtocolVersion: 772}} diff --git a/proto_generated/v1_21_8/proto.go b/proto_generated/v1_21_8/proto.go new file mode 100644 index 0000000..333ba04 --- /dev/null +++ b/proto_generated/v1_21_8/proto.go @@ -0,0 +1,28143 @@ +package v1_21_8 + +import ( + "encoding/binary" + "github.com/admin-else/strom/nbt" + "github.com/admin-else/strom/proto_base" + "github.com/google/uuid" + "io" +) + +type PlayToClientChatType struct { + TranslationKey string + Parameters []PlayToClientChatTypeParameterType + Style nbt.Anon +} + +func (ret *PlayToClientChatType) Decode(r io.Reader) (err error) { + ret.TranslationKey, err = proto_base.DecodeString(r) + if err != nil { + return + } + var lPlayToClientChatTypeParameters int32 + lPlayToClientChatTypeParameters, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Parameters = []PlayToClientChatTypeParameterType{} + for range lPlayToClientChatTypeParameters { + var PlayToClientChatTypeParametersElement PlayToClientChatTypeParameterType + err = PlayToClientChatTypeParametersElement.Decode(r) + if err != nil { + return + } + ret.Parameters = append(ret.Parameters, PlayToClientChatTypeParametersElement) + } + err = ret.Style.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientChatType) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.TranslationKey) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Parameters))) + if err != nil { + return + } + for iPlayToClientChatTypeParameters := range len(ret.Parameters) { + err = ret.Parameters[iPlayToClientChatTypeParameters].Encode(w) + if err != nil { + return + } + } + err = ret.Style.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientChatTypeParameterType struct { + Val string +} + +var PlayToClientChatTypeParameterTypeMap = map[int32]string{0: "content", 1: "sender", 2: "target"} + +func (ret *PlayToClientChatTypeParameterType) Decode(r io.Reader) (err error) { + var PlayToClientChatTypeParameterTypeKey int32 + PlayToClientChatTypeParameterTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Val, err = proto_base.ErroringIndex(PlayToClientChatTypeParameterTypeMap, PlayToClientChatTypeParameterTypeKey) + if err != nil { + return + } + return +} + +var PlayToClientChatTypeParameterTypeReverseMap = map[string]int32{"content": 0, "sender": 1, "target": 2} + +func (ret *PlayToClientChatTypeParameterType) Encode(w io.Writer) (err error) { + var vPlayToClientChatTypeParameterType int32 + vPlayToClientChatTypeParameterType, err = proto_base.ErroringIndex(PlayToClientChatTypeParameterTypeReverseMap, ret.Val) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientChatTypeParameterType) + if err != nil { + return + } + return +} + +type PlayToClientChatTypes struct { + Chat PlayToClientChatType + Narration PlayToClientChatType +} + +func (ret *PlayToClientChatTypes) Decode(r io.Reader) (err error) { + err = ret.Chat.Decode(r) + if err != nil { + return + } + err = ret.Narration.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientChatTypes) Encode(w io.Writer) (err error) { + err = ret.Chat.Encode(w) + if err != nil { + return + } + err = ret.Narration.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientChatTypesHolder struct { + Val any +} + +func (ret *PlayToClientChatTypesHolder) Decode(r io.Reader) (err error) { + var PlayToClientChatTypesHolderId int32 + PlayToClientChatTypesHolderId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + if PlayToClientChatTypesHolderId != 0 { + ret.Val = PlayToClientChatTypesHolderId + } else { + var PlayToClientChatTypesHolderResult PlayToClientChatTypes + err = PlayToClientChatTypesHolderResult.Decode(r) + if err != nil { + return + } + ret.Val = PlayToClientChatTypesHolderResult + } + return +} +func (ret *PlayToClientChatTypesHolder) Encode(w io.Writer) (err error) { + switch PlayToClientChatTypesHolderKnownType := ret.Val.(type) { + case int32: + err = proto_base.EncodeVarInt(w, PlayToClientChatTypesHolderKnownType) + if err != nil { + return + } + case PlayToClientChatTypes: + err = proto_base.EncodeVarInt(w, 0) + if err != nil { + return + } + err = PlayToClientChatTypesHolderKnownType.Encode(w) + if err != nil { + return + } + default: + err = proto_base.BadTypeError + } + return +} + +type PlayToClientPositionUpdateRelatives struct { + Val uint32 +} + +func (ret *PlayToClientPositionUpdateRelatives) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Val) + if err != nil { + return + } + return +} +func (ret *PlayToClientPositionUpdateRelatives) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Val) + if err != nil { + return + } + return +} + +type PlayToClientRecipeBookSetting struct { + Open bool + Filtering bool +} + +func (ret *PlayToClientRecipeBookSetting) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Open) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Filtering) + if err != nil { + return + } + return +} +func (ret *PlayToClientRecipeBookSetting) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Open) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Filtering) + if err != nil { + return + } + return +} + +type PlayToClientRecipeDisplay struct { + Type string + Data any +} + +var PlayToClientRecipeDisplayTypeMap = map[int32]string{0: "crafting_shapeless", 1: "crafting_shaped", 2: "furnace", 3: "stonecutter", 4: "smithing"} + +func (ret *PlayToClientRecipeDisplay) Decode(r io.Reader) (err error) { + var PlayToClientRecipeDisplayTypeKey int32 + PlayToClientRecipeDisplayTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Type, err = proto_base.ErroringIndex(PlayToClientRecipeDisplayTypeMap, PlayToClientRecipeDisplayTypeKey) + if err != nil { + return + } + switch ret.Type { + case "crafting_shaped": + var PlayToClientRecipeDisplayDataCraftingShapedTmp struct { + Width int32 + Height int32 + Ingredients []PlayToClientSlotDisplay + Result PlayToClientSlotDisplay + CraftingStation PlayToClientSlotDisplay + } + PlayToClientRecipeDisplayDataCraftingShapedTmp.Width, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientRecipeDisplayDataCraftingShapedTmp.Height, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lPlayToClientRecipeDisplayDataIngredients int32 + lPlayToClientRecipeDisplayDataIngredients, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientRecipeDisplayDataCraftingShapedTmp.Ingredients = []PlayToClientSlotDisplay{} + for range lPlayToClientRecipeDisplayDataIngredients { + var PlayToClientRecipeDisplayDataIngredientsElement PlayToClientSlotDisplay + err = PlayToClientRecipeDisplayDataIngredientsElement.Decode(r) + if err != nil { + return + } + PlayToClientRecipeDisplayDataCraftingShapedTmp.Ingredients = append(PlayToClientRecipeDisplayDataCraftingShapedTmp.Ingredients, PlayToClientRecipeDisplayDataIngredientsElement) + } + err = PlayToClientRecipeDisplayDataCraftingShapedTmp.Result.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataCraftingShapedTmp.CraftingStation.Decode(r) + if err != nil { + return + } + ret.Data = PlayToClientRecipeDisplayDataCraftingShapedTmp + case "crafting_shapeless": + var PlayToClientRecipeDisplayDataCraftingShapelessTmp struct { + Ingredients []PlayToClientSlotDisplay + Result PlayToClientSlotDisplay + CraftingStation PlayToClientSlotDisplay + } + var lPlayToClientRecipeDisplayDataIngredients int32 + lPlayToClientRecipeDisplayDataIngredients, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientRecipeDisplayDataCraftingShapelessTmp.Ingredients = []PlayToClientSlotDisplay{} + for range lPlayToClientRecipeDisplayDataIngredients { + var PlayToClientRecipeDisplayDataIngredientsElement PlayToClientSlotDisplay + err = PlayToClientRecipeDisplayDataIngredientsElement.Decode(r) + if err != nil { + return + } + PlayToClientRecipeDisplayDataCraftingShapelessTmp.Ingredients = append(PlayToClientRecipeDisplayDataCraftingShapelessTmp.Ingredients, PlayToClientRecipeDisplayDataIngredientsElement) + } + err = PlayToClientRecipeDisplayDataCraftingShapelessTmp.Result.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataCraftingShapelessTmp.CraftingStation.Decode(r) + if err != nil { + return + } + ret.Data = PlayToClientRecipeDisplayDataCraftingShapelessTmp + case "furnace": + var PlayToClientRecipeDisplayDataFurnaceTmp struct { + Ingredient PlayToClientSlotDisplay + Fuel PlayToClientSlotDisplay + Result PlayToClientSlotDisplay + CraftingStation PlayToClientSlotDisplay + Duration int32 + Experience float32 + } + err = PlayToClientRecipeDisplayDataFurnaceTmp.Ingredient.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataFurnaceTmp.Fuel.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataFurnaceTmp.Result.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataFurnaceTmp.CraftingStation.Decode(r) + if err != nil { + return + } + PlayToClientRecipeDisplayDataFurnaceTmp.Duration, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientRecipeDisplayDataFurnaceTmp.Experience) + if err != nil { + return + } + ret.Data = PlayToClientRecipeDisplayDataFurnaceTmp + case "smithing": + var PlayToClientRecipeDisplayDataSmithingTmp struct { + Template PlayToClientSlotDisplay + Base PlayToClientSlotDisplay + Addition PlayToClientSlotDisplay + Result PlayToClientSlotDisplay + CraftingStation PlayToClientSlotDisplay + } + err = PlayToClientRecipeDisplayDataSmithingTmp.Template.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataSmithingTmp.Base.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataSmithingTmp.Addition.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataSmithingTmp.Result.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataSmithingTmp.CraftingStation.Decode(r) + if err != nil { + return + } + ret.Data = PlayToClientRecipeDisplayDataSmithingTmp + case "stonecutter": + var PlayToClientRecipeDisplayDataStonecutterTmp struct { + Ingredient PlayToClientSlotDisplay + Result PlayToClientSlotDisplay + CraftingStation PlayToClientSlotDisplay + } + err = PlayToClientRecipeDisplayDataStonecutterTmp.Ingredient.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataStonecutterTmp.Result.Decode(r) + if err != nil { + return + } + err = PlayToClientRecipeDisplayDataStonecutterTmp.CraftingStation.Decode(r) + if err != nil { + return + } + ret.Data = PlayToClientRecipeDisplayDataStonecutterTmp + } + return +} + +var PlayToClientRecipeDisplayTypeReverseMap = map[string]int32{"crafting_shapeless": 0, "crafting_shaped": 1, "furnace": 2, "stonecutter": 3, "smithing": 4} + +func (ret *PlayToClientRecipeDisplay) Encode(w io.Writer) (err error) { + var vPlayToClientRecipeDisplayType int32 + vPlayToClientRecipeDisplayType, err = proto_base.ErroringIndex(PlayToClientRecipeDisplayTypeReverseMap, ret.Type) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientRecipeDisplayType) + if err != nil { + return + } + switch ret.Type { + case "crafting_shaped": + PlayToClientRecipeDisplayData, ok := ret.Data.(struct { + Width int32 + Height int32 + Ingredients []PlayToClientSlotDisplay + Result PlayToClientSlotDisplay + CraftingStation PlayToClientSlotDisplay + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientRecipeDisplayData.Width) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, PlayToClientRecipeDisplayData.Height) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(PlayToClientRecipeDisplayData.Ingredients))) + if err != nil { + return + } + for iPlayToClientRecipeDisplayDataIngredients := range len(PlayToClientRecipeDisplayData.Ingredients) { + err = PlayToClientRecipeDisplayData.Ingredients[iPlayToClientRecipeDisplayDataIngredients].Encode(w) + if err != nil { + return + } + } + err = PlayToClientRecipeDisplayData.Result.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w) + if err != nil { + return + } + case "crafting_shapeless": + PlayToClientRecipeDisplayData, ok := ret.Data.(struct { + Ingredients []PlayToClientSlotDisplay + Result PlayToClientSlotDisplay + CraftingStation PlayToClientSlotDisplay + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, int32(len(PlayToClientRecipeDisplayData.Ingredients))) + if err != nil { + return + } + for iPlayToClientRecipeDisplayDataIngredients := range len(PlayToClientRecipeDisplayData.Ingredients) { + err = PlayToClientRecipeDisplayData.Ingredients[iPlayToClientRecipeDisplayDataIngredients].Encode(w) + if err != nil { + return + } + } + err = PlayToClientRecipeDisplayData.Result.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w) + if err != nil { + return + } + case "furnace": + PlayToClientRecipeDisplayData, ok := ret.Data.(struct { + Ingredient PlayToClientSlotDisplay + Fuel PlayToClientSlotDisplay + Result PlayToClientSlotDisplay + CraftingStation PlayToClientSlotDisplay + Duration int32 + Experience float32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientRecipeDisplayData.Ingredient.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.Fuel.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.Result.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, PlayToClientRecipeDisplayData.Duration) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientRecipeDisplayData.Experience) + if err != nil { + return + } + case "smithing": + PlayToClientRecipeDisplayData, ok := ret.Data.(struct { + Template PlayToClientSlotDisplay + Base PlayToClientSlotDisplay + Addition PlayToClientSlotDisplay + Result PlayToClientSlotDisplay + CraftingStation PlayToClientSlotDisplay + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientRecipeDisplayData.Template.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.Base.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.Addition.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.Result.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w) + if err != nil { + return + } + case "stonecutter": + PlayToClientRecipeDisplayData, ok := ret.Data.(struct { + Ingredient PlayToClientSlotDisplay + Result PlayToClientSlotDisplay + CraftingStation PlayToClientSlotDisplay + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientRecipeDisplayData.Ingredient.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.Result.Encode(w) + if err != nil { + return + } + err = PlayToClientRecipeDisplayData.CraftingStation.Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientSlotDisplay struct { + Type string + Data any +} + +var PlayToClientSlotDisplayTypeMap = map[int32]string{0: "empty", 1: "any_fuel", 2: "item", 3: "item_stack", 4: "tag", 5: "smithing_trim", 6: "with_remainder", 7: "composite"} + +func (ret *PlayToClientSlotDisplay) Decode(r io.Reader) (err error) { + var PlayToClientSlotDisplayTypeKey int32 + PlayToClientSlotDisplayTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Type, err = proto_base.ErroringIndex(PlayToClientSlotDisplayTypeMap, PlayToClientSlotDisplayTypeKey) + if err != nil { + return + } + switch ret.Type { + case "any_fuel": + var PlayToClientSlotDisplayDataAnyFuelTmp struct { + } + ret.Data = PlayToClientSlotDisplayDataAnyFuelTmp + case "composite": + var PlayToClientSlotDisplayDataCompositeTmp []PlayToClientSlotDisplay + var lPlayToClientSlotDisplayData int32 + lPlayToClientSlotDisplayData, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientSlotDisplayDataCompositeTmp = []PlayToClientSlotDisplay{} + for range lPlayToClientSlotDisplayData { + var PlayToClientSlotDisplayDataElement PlayToClientSlotDisplay + err = PlayToClientSlotDisplayDataElement.Decode(r) + if err != nil { + return + } + PlayToClientSlotDisplayDataCompositeTmp = append(PlayToClientSlotDisplayDataCompositeTmp, PlayToClientSlotDisplayDataElement) + } + ret.Data = PlayToClientSlotDisplayDataCompositeTmp + case "empty": + var PlayToClientSlotDisplayDataEmptyTmp struct { + } + ret.Data = PlayToClientSlotDisplayDataEmptyTmp + case "item": + var PlayToClientSlotDisplayDataItemTmp int32 + PlayToClientSlotDisplayDataItemTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Data = PlayToClientSlotDisplayDataItemTmp + case "item_stack": + var PlayToClientSlotDisplayDataItemStackTmp Slot + err = PlayToClientSlotDisplayDataItemStackTmp.Decode(r) + if err != nil { + return + } + ret.Data = PlayToClientSlotDisplayDataItemStackTmp + case "smithing_trim": + var PlayToClientSlotDisplayDataSmithingTrimTmp struct { + Base PlayToClientSlotDisplay + Material PlayToClientSlotDisplay + Pattern any + } + err = PlayToClientSlotDisplayDataSmithingTrimTmp.Base.Decode(r) + if err != nil { + return + } + err = PlayToClientSlotDisplayDataSmithingTrimTmp.Material.Decode(r) + if err != nil { + return + } + var PlayToClientSlotDisplayDataPatternId int32 + PlayToClientSlotDisplayDataPatternId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + if PlayToClientSlotDisplayDataPatternId != 0 { + PlayToClientSlotDisplayDataSmithingTrimTmp.Pattern = PlayToClientSlotDisplayDataPatternId + } else { + var PlayToClientSlotDisplayDataPatternResult ArmorTrimPattern + err = PlayToClientSlotDisplayDataPatternResult.Decode(r) + if err != nil { + return + } + PlayToClientSlotDisplayDataSmithingTrimTmp.Pattern = PlayToClientSlotDisplayDataPatternResult + } + ret.Data = PlayToClientSlotDisplayDataSmithingTrimTmp + case "tag": + var PlayToClientSlotDisplayDataTagTmp string + PlayToClientSlotDisplayDataTagTmp, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Data = PlayToClientSlotDisplayDataTagTmp + case "with_remainder": + var PlayToClientSlotDisplayDataWithRemainderTmp struct { + Input PlayToClientSlotDisplay + Remainder PlayToClientSlotDisplay + } + err = PlayToClientSlotDisplayDataWithRemainderTmp.Input.Decode(r) + if err != nil { + return + } + err = PlayToClientSlotDisplayDataWithRemainderTmp.Remainder.Decode(r) + if err != nil { + return + } + ret.Data = PlayToClientSlotDisplayDataWithRemainderTmp + } + return +} + +var PlayToClientSlotDisplayTypeReverseMap = map[string]int32{"empty": 0, "any_fuel": 1, "item": 2, "item_stack": 3, "tag": 4, "smithing_trim": 5, "with_remainder": 6, "composite": 7} + +func (ret *PlayToClientSlotDisplay) Encode(w io.Writer) (err error) { + var vPlayToClientSlotDisplayType int32 + vPlayToClientSlotDisplayType, err = proto_base.ErroringIndex(PlayToClientSlotDisplayTypeReverseMap, ret.Type) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientSlotDisplayType) + if err != nil { + return + } + switch ret.Type { + case "any_fuel": + _, ok := ret.Data.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "composite": + PlayToClientSlotDisplayData, ok := ret.Data.([]PlayToClientSlotDisplay) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, int32(len(PlayToClientSlotDisplayData))) + if err != nil { + return + } + for iPlayToClientSlotDisplayData := range len(PlayToClientSlotDisplayData) { + err = PlayToClientSlotDisplayData[iPlayToClientSlotDisplayData].Encode(w) + if err != nil { + return + } + } + case "empty": + _, ok := ret.Data.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "item": + PlayToClientSlotDisplayData, ok := ret.Data.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientSlotDisplayData) + if err != nil { + return + } + case "item_stack": + PlayToClientSlotDisplayData, ok := ret.Data.(Slot) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientSlotDisplayData.Encode(w) + if err != nil { + return + } + case "smithing_trim": + PlayToClientSlotDisplayData, ok := ret.Data.(struct { + Base PlayToClientSlotDisplay + Material PlayToClientSlotDisplay + Pattern any + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientSlotDisplayData.Base.Encode(w) + if err != nil { + return + } + err = PlayToClientSlotDisplayData.Material.Encode(w) + if err != nil { + return + } + switch PlayToClientSlotDisplayDataPatternKnownType := PlayToClientSlotDisplayData.Pattern.(type) { + case int32: + err = proto_base.EncodeVarInt(w, PlayToClientSlotDisplayDataPatternKnownType) + if err != nil { + return + } + case ArmorTrimPattern: + err = proto_base.EncodeVarInt(w, 0) + if err != nil { + return + } + err = PlayToClientSlotDisplayDataPatternKnownType.Encode(w) + if err != nil { + return + } + default: + err = proto_base.BadTypeError + } + case "tag": + PlayToClientSlotDisplayData, ok := ret.Data.(string) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, PlayToClientSlotDisplayData) + if err != nil { + return + } + case "with_remainder": + PlayToClientSlotDisplayData, ok := ret.Data.(struct { + Input PlayToClientSlotDisplay + Remainder PlayToClientSlotDisplay + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientSlotDisplayData.Input.Encode(w) + if err != nil { + return + } + err = PlayToClientSlotDisplayData.Remainder.Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientSpawnInfo struct { + Dimension int32 + Name string + HashedSeed int64 + Gamemode string + PreviousGamemode uint8 + IsDebug bool + IsFlat bool + Death *struct { + DimensionName string + Location Position + } + PortalCooldown int32 + SeaLevel int32 +} + +var PlayToClientSpawnInfoGamemodeMap = map[int8]string{0: "survival", 1: "creative", 2: "adventure", 3: "spectator"} + +func (ret *PlayToClientSpawnInfo) Decode(r io.Reader) (err error) { + ret.Dimension, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.HashedSeed) + if err != nil { + return + } + var PlayToClientSpawnInfoGamemodeKey int8 + err = binary.Read(r, binary.BigEndian, &PlayToClientSpawnInfoGamemodeKey) + if err != nil { + return + } + ret.Gamemode, err = proto_base.ErroringIndex(PlayToClientSpawnInfoGamemodeMap, PlayToClientSpawnInfoGamemodeKey) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.PreviousGamemode) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IsDebug) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IsFlat) + if err != nil { + return + } + var PlayToClientSpawnInfoDeathPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientSpawnInfoDeathPresent) + if err != nil { + return + } + if PlayToClientSpawnInfoDeathPresent { + var PlayToClientSpawnInfoDeathPresentValue struct { + DimensionName string + Location Position + } + PlayToClientSpawnInfoDeathPresentValue.DimensionName, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = PlayToClientSpawnInfoDeathPresentValue.Location.Decode(r) + if err != nil { + return + } + ret.Death = &PlayToClientSpawnInfoDeathPresentValue + } + ret.PortalCooldown, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SeaLevel, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} + +var PlayToClientSpawnInfoGamemodeReverseMap = map[string]int8{"survival": 0, "creative": 1, "adventure": 2, "spectator": 3} + +func (ret *PlayToClientSpawnInfo) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Dimension) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Name) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.HashedSeed) + if err != nil { + return + } + var vPlayToClientSpawnInfoGamemode int8 + vPlayToClientSpawnInfoGamemode, err = proto_base.ErroringIndex(PlayToClientSpawnInfoGamemodeReverseMap, ret.Gamemode) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, vPlayToClientSpawnInfoGamemode) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PreviousGamemode) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IsDebug) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IsFlat) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Death != nil) + if err != nil { + return + } + if ret.Death != nil { + err = proto_base.EncodeString(w, (*ret.Death).DimensionName) + if err != nil { + return + } + err = (*ret.Death).Location.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, ret.PortalCooldown) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.SeaLevel) + if err != nil { + return + } + return +} + +type PlayToClientPacket struct { + Name string + Params any +} + +var PlayToClientPacketNameMap = map[int32]string{0x00: "bundle_delimiter", 0x01: "spawn_entity", 0x02: "animation", 0x03: "statistics", 0x04: "acknowledge_player_digging", 0x05: "block_break_animation", 0x06: "tile_entity_data", 0x07: "block_action", 0x08: "block_change", 0x09: "boss_bar", 0x0a: "difficulty", 0x0b: "chunk_batch_finished", 0x0c: "chunk_batch_start", 0x0d: "chunk_biomes", 0x0e: "clear_titles", 0x0f: "tab_complete", 0x10: "declare_commands", 0x11: "close_window", 0x12: "window_items", 0x13: "craft_progress_bar", 0x14: "set_slot", 0x15: "cookie_request", 0x16: "set_cooldown", 0x17: "chat_suggestions", 0x18: "custom_payload", 0x19: "damage_event", 0x1a: "debug_sample", 0x1b: "hide_message", 0x1c: "kick_disconnect", 0x1d: "profileless_chat", 0x1e: "entity_status", 0x1f: "sync_entity_position", 0x20: "explosion", 0x21: "unload_chunk", 0x22: "game_state_change", 0x23: "open_horse_window", 0x24: "hurt_animation", 0x25: "initialize_world_border", 0x26: "keep_alive", 0x27: "map_chunk", 0x28: "world_event", 0x29: "world_particles", 0x2a: "update_light", 0x2b: "login", 0x2c: "map", 0x2d: "trade_list", 0x2e: "rel_entity_move", 0x2f: "entity_move_look", 0x30: "move_minecart", 0x31: "entity_look", 0x32: "vehicle_move", 0x33: "open_book", 0x34: "open_window", 0x35: "open_sign_entity", 0x36: "ping", 0x37: "ping_response", 0x38: "craft_recipe_response", 0x39: "abilities", 0x3a: "player_chat", 0x3b: "end_combat_event", 0x3c: "enter_combat_event", 0x3d: "death_combat_event", 0x3e: "player_remove", 0x3f: "player_info", 0x40: "face_player", 0x41: "position", 0x42: "player_rotation", 0x43: "recipe_book_add", 0x44: "recipe_book_remove", 0x45: "recipe_book_settings", 0x46: "entity_destroy", 0x47: "remove_entity_effect", 0x48: "reset_score", 0x49: "remove_resource_pack", 0x4a: "add_resource_pack", 0x4b: "respawn", 0x4c: "entity_head_rotation", 0x4d: "multi_block_change", 0x4e: "select_advancement_tab", 0x4f: "server_data", 0x50: "action_bar", 0x51: "world_border_center", 0x52: "world_border_lerp_size", 0x53: "world_border_size", 0x54: "world_border_warning_delay", 0x55: "world_border_warning_reach", 0x56: "camera", 0x57: "update_view_position", 0x58: "update_view_distance", 0x59: "set_cursor_item", 0x5a: "spawn_position", 0x5b: "scoreboard_display_objective", 0x5c: "entity_metadata", 0x5d: "attach_entity", 0x5e: "entity_velocity", 0x5f: "entity_equipment", 0x60: "experience", 0x61: "update_health", 0x62: "held_item_slot", 0x63: "scoreboard_objective", 0x64: "set_passengers", 0x65: "set_player_inventory", 0x66: "teams", 0x67: "scoreboard_score", 0x68: "simulation_distance", 0x69: "set_title_subtitle", 0x6a: "update_time", 0x6b: "set_title_text", 0x6c: "set_title_time", 0x6d: "entity_sound_effect", 0x6e: "sound_effect", 0x6f: "start_configuration", 0x70: "stop_sound", 0x71: "store_cookie", 0x72: "system_chat", 0x73: "playerlist_header", 0x74: "nbt_query_response", 0x75: "collect", 0x76: "entity_teleport", 0x77: "test_instance_block_status", 0x78: "set_ticking_state", 0x79: "step_tick", 0x7a: "transfer", 0x7b: "advancements", 0x7c: "entity_update_attributes", 0x7d: "entity_effect", 0x7e: "declare_recipes", 0x7f: "tags", 0x80: "set_projectile_power", 0x81: "custom_report_details", 0x82: "server_links", 0x83: "tracked_waypoint", 0x84: "clear_dialog", 0x85: "show_dialog"} + +func (ret *PlayToClientPacket) Decode(r io.Reader) (err error) { + var PlayToClientPacketNameKey int32 + PlayToClientPacketNameKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.ErroringIndex(PlayToClientPacketNameMap, PlayToClientPacketNameKey) + if err != nil { + return + } + switch ret.Name { + case "abilities": + var PlayToClientPacketParamsAbilitiesTmp PlayToClientPacketAbilities + err = PlayToClientPacketParamsAbilitiesTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsAbilitiesTmp + case "acknowledge_player_digging": + var PlayToClientPacketParamsAcknowledgePlayerDiggingTmp PlayToClientPacketAcknowledgePlayerDigging + err = PlayToClientPacketParamsAcknowledgePlayerDiggingTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsAcknowledgePlayerDiggingTmp + case "action_bar": + var PlayToClientPacketParamsActionBarTmp PlayToClientPacketActionBar + err = PlayToClientPacketParamsActionBarTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsActionBarTmp + case "add_resource_pack": + var PlayToClientPacketParamsAddResourcePackTmp PlayToClientPacketCommonAddResourcePack + err = PlayToClientPacketParamsAddResourcePackTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsAddResourcePackTmp + case "advancements": + var PlayToClientPacketParamsAdvancementsTmp PlayToClientPacketAdvancements + err = PlayToClientPacketParamsAdvancementsTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsAdvancementsTmp + case "animation": + var PlayToClientPacketParamsAnimationTmp PlayToClientPacketAnimation + err = PlayToClientPacketParamsAnimationTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsAnimationTmp + case "attach_entity": + var PlayToClientPacketParamsAttachEntityTmp PlayToClientPacketAttachEntity + err = PlayToClientPacketParamsAttachEntityTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsAttachEntityTmp + case "block_action": + var PlayToClientPacketParamsBlockActionTmp PlayToClientPacketBlockAction + err = PlayToClientPacketParamsBlockActionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsBlockActionTmp + case "block_break_animation": + var PlayToClientPacketParamsBlockBreakAnimationTmp PlayToClientPacketBlockBreakAnimation + err = PlayToClientPacketParamsBlockBreakAnimationTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsBlockBreakAnimationTmp + case "block_change": + var PlayToClientPacketParamsBlockChangeTmp PlayToClientPacketBlockChange + err = PlayToClientPacketParamsBlockChangeTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsBlockChangeTmp + case "boss_bar": + var PlayToClientPacketParamsBossBarTmp PlayToClientPacketBossBar + err = PlayToClientPacketParamsBossBarTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsBossBarTmp + case "bundle_delimiter": + var PlayToClientPacketParamsBundleDelimiterTmp PlayToClientPacketBundleDelimiter + err = PlayToClientPacketParamsBundleDelimiterTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsBundleDelimiterTmp + case "camera": + var PlayToClientPacketParamsCameraTmp PlayToClientPacketCamera + err = PlayToClientPacketParamsCameraTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsCameraTmp + case "chat_suggestions": + var PlayToClientPacketParamsChatSuggestionsTmp PlayToClientPacketChatSuggestions + err = PlayToClientPacketParamsChatSuggestionsTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsChatSuggestionsTmp + case "chunk_batch_finished": + var PlayToClientPacketParamsChunkBatchFinishedTmp PlayToClientPacketChunkBatchFinished + err = PlayToClientPacketParamsChunkBatchFinishedTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsChunkBatchFinishedTmp + case "chunk_batch_start": + var PlayToClientPacketParamsChunkBatchStartTmp PlayToClientPacketChunkBatchStart + err = PlayToClientPacketParamsChunkBatchStartTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsChunkBatchStartTmp + case "chunk_biomes": + var PlayToClientPacketParamsChunkBiomesTmp PlayToClientPacketChunkBiomes + err = PlayToClientPacketParamsChunkBiomesTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsChunkBiomesTmp + case "clear_dialog": + var PlayToClientPacketParamsClearDialogTmp PlayToClientPacketCommonClearDialog + err = PlayToClientPacketParamsClearDialogTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsClearDialogTmp + case "clear_titles": + var PlayToClientPacketParamsClearTitlesTmp PlayToClientPacketClearTitles + err = PlayToClientPacketParamsClearTitlesTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsClearTitlesTmp + case "close_window": + var PlayToClientPacketParamsCloseWindowTmp PlayToClientPacketCloseWindow + err = PlayToClientPacketParamsCloseWindowTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsCloseWindowTmp + case "collect": + var PlayToClientPacketParamsCollectTmp PlayToClientPacketCollect + err = PlayToClientPacketParamsCollectTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsCollectTmp + case "cookie_request": + var PlayToClientPacketParamsCookieRequestTmp PlayToClientPacketCommonCookieRequest + err = PlayToClientPacketParamsCookieRequestTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsCookieRequestTmp + case "craft_progress_bar": + var PlayToClientPacketParamsCraftProgressBarTmp PlayToClientPacketCraftProgressBar + err = PlayToClientPacketParamsCraftProgressBarTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsCraftProgressBarTmp + case "craft_recipe_response": + var PlayToClientPacketParamsCraftRecipeResponseTmp PlayToClientPacketCraftRecipeResponse + err = PlayToClientPacketParamsCraftRecipeResponseTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsCraftRecipeResponseTmp + case "custom_payload": + var PlayToClientPacketParamsCustomPayloadTmp PlayToClientPacketCustomPayload + err = PlayToClientPacketParamsCustomPayloadTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsCustomPayloadTmp + case "custom_report_details": + var PlayToClientPacketParamsCustomReportDetailsTmp PlayToClientPacketCommonCustomReportDetails + err = PlayToClientPacketParamsCustomReportDetailsTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsCustomReportDetailsTmp + case "damage_event": + var PlayToClientPacketParamsDamageEventTmp PlayToClientPacketDamageEvent + err = PlayToClientPacketParamsDamageEventTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsDamageEventTmp + case "death_combat_event": + var PlayToClientPacketParamsDeathCombatEventTmp PlayToClientPacketDeathCombatEvent + err = PlayToClientPacketParamsDeathCombatEventTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsDeathCombatEventTmp + case "debug_sample": + var PlayToClientPacketParamsDebugSampleTmp PlayToClientPacketDebugSample + err = PlayToClientPacketParamsDebugSampleTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsDebugSampleTmp + case "declare_commands": + var PlayToClientPacketParamsDeclareCommandsTmp PlayToClientPacketDeclareCommands + err = PlayToClientPacketParamsDeclareCommandsTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsDeclareCommandsTmp + case "declare_recipes": + var PlayToClientPacketParamsDeclareRecipesTmp PlayToClientPacketDeclareRecipes + err = PlayToClientPacketParamsDeclareRecipesTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsDeclareRecipesTmp + case "difficulty": + var PlayToClientPacketParamsDifficultyTmp PlayToClientPacketDifficulty + err = PlayToClientPacketParamsDifficultyTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsDifficultyTmp + case "end_combat_event": + var PlayToClientPacketParamsEndCombatEventTmp PlayToClientPacketEndCombatEvent + err = PlayToClientPacketParamsEndCombatEventTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEndCombatEventTmp + case "enter_combat_event": + var PlayToClientPacketParamsEnterCombatEventTmp PlayToClientPacketEnterCombatEvent + err = PlayToClientPacketParamsEnterCombatEventTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEnterCombatEventTmp + case "entity_destroy": + var PlayToClientPacketParamsEntityDestroyTmp PlayToClientPacketEntityDestroy + err = PlayToClientPacketParamsEntityDestroyTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityDestroyTmp + case "entity_effect": + var PlayToClientPacketParamsEntityEffectTmp PlayToClientPacketEntityEffect + err = PlayToClientPacketParamsEntityEffectTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityEffectTmp + case "entity_equipment": + var PlayToClientPacketParamsEntityEquipmentTmp PlayToClientPacketEntityEquipment + err = PlayToClientPacketParamsEntityEquipmentTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityEquipmentTmp + case "entity_head_rotation": + var PlayToClientPacketParamsEntityHeadRotationTmp PlayToClientPacketEntityHeadRotation + err = PlayToClientPacketParamsEntityHeadRotationTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityHeadRotationTmp + case "entity_look": + var PlayToClientPacketParamsEntityLookTmp PlayToClientPacketEntityLook + err = PlayToClientPacketParamsEntityLookTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityLookTmp + case "entity_metadata": + var PlayToClientPacketParamsEntityMetadataTmp PlayToClientPacketEntityMetadata + err = PlayToClientPacketParamsEntityMetadataTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityMetadataTmp + case "entity_move_look": + var PlayToClientPacketParamsEntityMoveLookTmp PlayToClientPacketEntityMoveLook + err = PlayToClientPacketParamsEntityMoveLookTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityMoveLookTmp + case "entity_sound_effect": + var PlayToClientPacketParamsEntitySoundEffectTmp PlayToClientPacketEntitySoundEffect + err = PlayToClientPacketParamsEntitySoundEffectTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntitySoundEffectTmp + case "entity_status": + var PlayToClientPacketParamsEntityStatusTmp PlayToClientPacketEntityStatus + err = PlayToClientPacketParamsEntityStatusTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityStatusTmp + case "entity_teleport": + var PlayToClientPacketParamsEntityTeleportTmp PlayToClientPacketEntityTeleport + err = PlayToClientPacketParamsEntityTeleportTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityTeleportTmp + case "entity_update_attributes": + var PlayToClientPacketParamsEntityUpdateAttributesTmp PlayToClientPacketEntityUpdateAttributes + err = PlayToClientPacketParamsEntityUpdateAttributesTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityUpdateAttributesTmp + case "entity_velocity": + var PlayToClientPacketParamsEntityVelocityTmp PlayToClientPacketEntityVelocity + err = PlayToClientPacketParamsEntityVelocityTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsEntityVelocityTmp + case "experience": + var PlayToClientPacketParamsExperienceTmp PlayToClientPacketExperience + err = PlayToClientPacketParamsExperienceTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsExperienceTmp + case "explosion": + var PlayToClientPacketParamsExplosionTmp PlayToClientPacketExplosion + err = PlayToClientPacketParamsExplosionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsExplosionTmp + case "face_player": + var PlayToClientPacketParamsFacePlayerTmp PlayToClientPacketFacePlayer + err = PlayToClientPacketParamsFacePlayerTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsFacePlayerTmp + case "game_state_change": + var PlayToClientPacketParamsGameStateChangeTmp PlayToClientPacketGameStateChange + err = PlayToClientPacketParamsGameStateChangeTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsGameStateChangeTmp + case "held_item_slot": + var PlayToClientPacketParamsHeldItemSlotTmp PlayToClientPacketHeldItemSlot + err = PlayToClientPacketParamsHeldItemSlotTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsHeldItemSlotTmp + case "hide_message": + var PlayToClientPacketParamsHideMessageTmp PlayToClientPacketHideMessage + err = PlayToClientPacketParamsHideMessageTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsHideMessageTmp + case "hurt_animation": + var PlayToClientPacketParamsHurtAnimationTmp PlayToClientPacketHurtAnimation + err = PlayToClientPacketParamsHurtAnimationTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsHurtAnimationTmp + case "initialize_world_border": + var PlayToClientPacketParamsInitializeWorldBorderTmp PlayToClientPacketInitializeWorldBorder + err = PlayToClientPacketParamsInitializeWorldBorderTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsInitializeWorldBorderTmp + case "keep_alive": + var PlayToClientPacketParamsKeepAliveTmp PlayToClientPacketKeepAlive + err = PlayToClientPacketParamsKeepAliveTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsKeepAliveTmp + case "kick_disconnect": + var PlayToClientPacketParamsKickDisconnectTmp PlayToClientPacketKickDisconnect + err = PlayToClientPacketParamsKickDisconnectTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsKickDisconnectTmp + case "login": + var PlayToClientPacketParamsLoginTmp PlayToClientPacketLogin + err = PlayToClientPacketParamsLoginTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsLoginTmp + case "map": + var PlayToClientPacketParamsMapTmp PlayToClientPacketMap + err = PlayToClientPacketParamsMapTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsMapTmp + case "map_chunk": + var PlayToClientPacketParamsMapChunkTmp PlayToClientPacketMapChunk + err = PlayToClientPacketParamsMapChunkTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsMapChunkTmp + case "move_minecart": + var PlayToClientPacketParamsMoveMinecartTmp PlayToClientPacketMoveMinecart + err = PlayToClientPacketParamsMoveMinecartTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsMoveMinecartTmp + case "multi_block_change": + var PlayToClientPacketParamsMultiBlockChangeTmp PlayToClientPacketMultiBlockChange + err = PlayToClientPacketParamsMultiBlockChangeTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsMultiBlockChangeTmp + case "nbt_query_response": + var PlayToClientPacketParamsNbtQueryResponseTmp PlayToClientPacketNbtQueryResponse + err = PlayToClientPacketParamsNbtQueryResponseTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsNbtQueryResponseTmp + case "open_book": + var PlayToClientPacketParamsOpenBookTmp PlayToClientPacketOpenBook + err = PlayToClientPacketParamsOpenBookTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsOpenBookTmp + case "open_horse_window": + var PlayToClientPacketParamsOpenHorseWindowTmp PlayToClientPacketOpenHorseWindow + err = PlayToClientPacketParamsOpenHorseWindowTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsOpenHorseWindowTmp + case "open_sign_entity": + var PlayToClientPacketParamsOpenSignEntityTmp PlayToClientPacketOpenSignEntity + err = PlayToClientPacketParamsOpenSignEntityTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsOpenSignEntityTmp + case "open_window": + var PlayToClientPacketParamsOpenWindowTmp PlayToClientPacketOpenWindow + err = PlayToClientPacketParamsOpenWindowTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsOpenWindowTmp + case "ping": + var PlayToClientPacketParamsPingTmp PlayToClientPacketPing + err = PlayToClientPacketParamsPingTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsPingTmp + case "ping_response": + var PlayToClientPacketParamsPingResponseTmp PlayToClientPacketPingResponse + err = PlayToClientPacketParamsPingResponseTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsPingResponseTmp + case "player_chat": + var PlayToClientPacketParamsPlayerChatTmp PlayToClientPacketPlayerChat + err = PlayToClientPacketParamsPlayerChatTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsPlayerChatTmp + case "player_info": + var PlayToClientPacketParamsPlayerInfoTmp PlayToClientPacketPlayerInfo + err = PlayToClientPacketParamsPlayerInfoTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsPlayerInfoTmp + case "player_remove": + var PlayToClientPacketParamsPlayerRemoveTmp PlayToClientPacketPlayerRemove + err = PlayToClientPacketParamsPlayerRemoveTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsPlayerRemoveTmp + case "player_rotation": + var PlayToClientPacketParamsPlayerRotationTmp PlayToClientPacketPlayerRotation + err = PlayToClientPacketParamsPlayerRotationTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsPlayerRotationTmp + case "playerlist_header": + var PlayToClientPacketParamsPlayerlistHeaderTmp PlayToClientPacketPlayerlistHeader + err = PlayToClientPacketParamsPlayerlistHeaderTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsPlayerlistHeaderTmp + case "position": + var PlayToClientPacketParamsPositionTmp PlayToClientPacketPosition + err = PlayToClientPacketParamsPositionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsPositionTmp + case "profileless_chat": + var PlayToClientPacketParamsProfilelessChatTmp PlayToClientPacketProfilelessChat + err = PlayToClientPacketParamsProfilelessChatTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsProfilelessChatTmp + case "recipe_book_add": + var PlayToClientPacketParamsRecipeBookAddTmp PlayToClientPacketRecipeBookAdd + err = PlayToClientPacketParamsRecipeBookAddTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsRecipeBookAddTmp + case "recipe_book_remove": + var PlayToClientPacketParamsRecipeBookRemoveTmp PlayToClientPacketRecipeBookRemove + err = PlayToClientPacketParamsRecipeBookRemoveTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsRecipeBookRemoveTmp + case "recipe_book_settings": + var PlayToClientPacketParamsRecipeBookSettingsTmp PlayToClientPacketRecipeBookSettings + err = PlayToClientPacketParamsRecipeBookSettingsTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsRecipeBookSettingsTmp + case "rel_entity_move": + var PlayToClientPacketParamsRelEntityMoveTmp PlayToClientPacketRelEntityMove + err = PlayToClientPacketParamsRelEntityMoveTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsRelEntityMoveTmp + case "remove_entity_effect": + var PlayToClientPacketParamsRemoveEntityEffectTmp PlayToClientPacketRemoveEntityEffect + err = PlayToClientPacketParamsRemoveEntityEffectTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsRemoveEntityEffectTmp + case "remove_resource_pack": + var PlayToClientPacketParamsRemoveResourcePackTmp PlayToClientPacketCommonRemoveResourcePack + err = PlayToClientPacketParamsRemoveResourcePackTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsRemoveResourcePackTmp + case "reset_score": + var PlayToClientPacketParamsResetScoreTmp PlayToClientPacketResetScore + err = PlayToClientPacketParamsResetScoreTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsResetScoreTmp + case "respawn": + var PlayToClientPacketParamsRespawnTmp PlayToClientPacketRespawn + err = PlayToClientPacketParamsRespawnTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsRespawnTmp + case "scoreboard_display_objective": + var PlayToClientPacketParamsScoreboardDisplayObjectiveTmp PlayToClientPacketScoreboardDisplayObjective + err = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsScoreboardDisplayObjectiveTmp + case "scoreboard_objective": + var PlayToClientPacketParamsScoreboardObjectiveTmp PlayToClientPacketScoreboardObjective + err = PlayToClientPacketParamsScoreboardObjectiveTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsScoreboardObjectiveTmp + case "scoreboard_score": + var PlayToClientPacketParamsScoreboardScoreTmp PlayToClientPacketScoreboardScore + err = PlayToClientPacketParamsScoreboardScoreTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsScoreboardScoreTmp + case "select_advancement_tab": + var PlayToClientPacketParamsSelectAdvancementTabTmp PlayToClientPacketSelectAdvancementTab + err = PlayToClientPacketParamsSelectAdvancementTabTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSelectAdvancementTabTmp + case "server_data": + var PlayToClientPacketParamsServerDataTmp PlayToClientPacketServerData + err = PlayToClientPacketParamsServerDataTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsServerDataTmp + case "server_links": + var PlayToClientPacketParamsServerLinksTmp PlayToClientPacketCommonServerLinks + err = PlayToClientPacketParamsServerLinksTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsServerLinksTmp + case "set_cooldown": + var PlayToClientPacketParamsSetCooldownTmp PlayToClientPacketSetCooldown + err = PlayToClientPacketParamsSetCooldownTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSetCooldownTmp + case "set_cursor_item": + var PlayToClientPacketParamsSetCursorItemTmp PlayToClientPacketSetCursorItem + err = PlayToClientPacketParamsSetCursorItemTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSetCursorItemTmp + case "set_passengers": + var PlayToClientPacketParamsSetPassengersTmp PlayToClientPacketSetPassengers + err = PlayToClientPacketParamsSetPassengersTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSetPassengersTmp + case "set_player_inventory": + var PlayToClientPacketParamsSetPlayerInventoryTmp PlayToClientPacketSetPlayerInventory + err = PlayToClientPacketParamsSetPlayerInventoryTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSetPlayerInventoryTmp + case "set_projectile_power": + var PlayToClientPacketParamsSetProjectilePowerTmp PlayToClientPacketSetProjectilePower + err = PlayToClientPacketParamsSetProjectilePowerTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSetProjectilePowerTmp + case "set_slot": + var PlayToClientPacketParamsSetSlotTmp PlayToClientPacketSetSlot + err = PlayToClientPacketParamsSetSlotTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSetSlotTmp + case "set_ticking_state": + var PlayToClientPacketParamsSetTickingStateTmp PlayToClientPacketSetTickingState + err = PlayToClientPacketParamsSetTickingStateTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSetTickingStateTmp + case "set_title_subtitle": + var PlayToClientPacketParamsSetTitleSubtitleTmp PlayToClientPacketSetTitleSubtitle + err = PlayToClientPacketParamsSetTitleSubtitleTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSetTitleSubtitleTmp + case "set_title_text": + var PlayToClientPacketParamsSetTitleTextTmp PlayToClientPacketSetTitleText + err = PlayToClientPacketParamsSetTitleTextTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSetTitleTextTmp + case "set_title_time": + var PlayToClientPacketParamsSetTitleTimeTmp PlayToClientPacketSetTitleTime + err = PlayToClientPacketParamsSetTitleTimeTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSetTitleTimeTmp + case "show_dialog": + var PlayToClientPacketParamsShowDialogTmp PlayToClientPacketShowDialog + err = PlayToClientPacketParamsShowDialogTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsShowDialogTmp + case "simulation_distance": + var PlayToClientPacketParamsSimulationDistanceTmp PlayToClientPacketSimulationDistance + err = PlayToClientPacketParamsSimulationDistanceTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSimulationDistanceTmp + case "sound_effect": + var PlayToClientPacketParamsSoundEffectTmp PlayToClientPacketSoundEffect + err = PlayToClientPacketParamsSoundEffectTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSoundEffectTmp + case "spawn_entity": + var PlayToClientPacketParamsSpawnEntityTmp PlayToClientPacketSpawnEntity + err = PlayToClientPacketParamsSpawnEntityTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSpawnEntityTmp + case "spawn_position": + var PlayToClientPacketParamsSpawnPositionTmp PlayToClientPacketSpawnPosition + err = PlayToClientPacketParamsSpawnPositionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSpawnPositionTmp + case "start_configuration": + var PlayToClientPacketParamsStartConfigurationTmp PlayToClientPacketStartConfiguration + err = PlayToClientPacketParamsStartConfigurationTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsStartConfigurationTmp + case "statistics": + var PlayToClientPacketParamsStatisticsTmp PlayToClientPacketStatistics + err = PlayToClientPacketParamsStatisticsTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsStatisticsTmp + case "step_tick": + var PlayToClientPacketParamsStepTickTmp PlayToClientPacketStepTick + err = PlayToClientPacketParamsStepTickTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsStepTickTmp + case "stop_sound": + var PlayToClientPacketParamsStopSoundTmp PlayToClientPacketStopSound + err = PlayToClientPacketParamsStopSoundTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsStopSoundTmp + case "store_cookie": + var PlayToClientPacketParamsStoreCookieTmp PlayToClientPacketCommonStoreCookie + err = PlayToClientPacketParamsStoreCookieTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsStoreCookieTmp + case "sync_entity_position": + var PlayToClientPacketParamsSyncEntityPositionTmp PlayToClientPacketSyncEntityPosition + err = PlayToClientPacketParamsSyncEntityPositionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSyncEntityPositionTmp + case "system_chat": + var PlayToClientPacketParamsSystemChatTmp PlayToClientPacketSystemChat + err = PlayToClientPacketParamsSystemChatTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsSystemChatTmp + case "tab_complete": + var PlayToClientPacketParamsTabCompleteTmp PlayToClientPacketTabComplete + err = PlayToClientPacketParamsTabCompleteTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsTabCompleteTmp + case "tags": + var PlayToClientPacketParamsTagsTmp PlayToClientPacketTags + err = PlayToClientPacketParamsTagsTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsTagsTmp + case "teams": + var PlayToClientPacketParamsTeamsTmp PlayToClientPacketTeams + err = PlayToClientPacketParamsTeamsTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsTeamsTmp + case "test_instance_block_status": + var PlayToClientPacketParamsTestInstanceBlockStatusTmp PlayToClientPacketTestInstanceBlockStatus + err = PlayToClientPacketParamsTestInstanceBlockStatusTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsTestInstanceBlockStatusTmp + case "tile_entity_data": + var PlayToClientPacketParamsTileEntityDataTmp PlayToClientPacketTileEntityData + err = PlayToClientPacketParamsTileEntityDataTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsTileEntityDataTmp + case "tracked_waypoint": + var PlayToClientPacketParamsTrackedWaypointTmp PlayToClientPacketTrackedWaypoint + err = PlayToClientPacketParamsTrackedWaypointTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsTrackedWaypointTmp + case "trade_list": + var PlayToClientPacketParamsTradeListTmp PlayToClientPacketTradeList + err = PlayToClientPacketParamsTradeListTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsTradeListTmp + case "transfer": + var PlayToClientPacketParamsTransferTmp PlayToClientPacketCommonTransfer + err = PlayToClientPacketParamsTransferTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsTransferTmp + case "unload_chunk": + var PlayToClientPacketParamsUnloadChunkTmp PlayToClientPacketUnloadChunk + err = PlayToClientPacketParamsUnloadChunkTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsUnloadChunkTmp + case "update_health": + var PlayToClientPacketParamsUpdateHealthTmp PlayToClientPacketUpdateHealth + err = PlayToClientPacketParamsUpdateHealthTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsUpdateHealthTmp + case "update_light": + var PlayToClientPacketParamsUpdateLightTmp PlayToClientPacketUpdateLight + err = PlayToClientPacketParamsUpdateLightTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsUpdateLightTmp + case "update_time": + var PlayToClientPacketParamsUpdateTimeTmp PlayToClientPacketUpdateTime + err = PlayToClientPacketParamsUpdateTimeTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsUpdateTimeTmp + case "update_view_distance": + var PlayToClientPacketParamsUpdateViewDistanceTmp PlayToClientPacketUpdateViewDistance + err = PlayToClientPacketParamsUpdateViewDistanceTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsUpdateViewDistanceTmp + case "update_view_position": + var PlayToClientPacketParamsUpdateViewPositionTmp PlayToClientPacketUpdateViewPosition + err = PlayToClientPacketParamsUpdateViewPositionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsUpdateViewPositionTmp + case "vehicle_move": + var PlayToClientPacketParamsVehicleMoveTmp PlayToClientPacketVehicleMove + err = PlayToClientPacketParamsVehicleMoveTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsVehicleMoveTmp + case "window_items": + var PlayToClientPacketParamsWindowItemsTmp PlayToClientPacketWindowItems + err = PlayToClientPacketParamsWindowItemsTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsWindowItemsTmp + case "world_border_center": + var PlayToClientPacketParamsWorldBorderCenterTmp PlayToClientPacketWorldBorderCenter + err = PlayToClientPacketParamsWorldBorderCenterTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsWorldBorderCenterTmp + case "world_border_lerp_size": + var PlayToClientPacketParamsWorldBorderLerpSizeTmp PlayToClientPacketWorldBorderLerpSize + err = PlayToClientPacketParamsWorldBorderLerpSizeTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsWorldBorderLerpSizeTmp + case "world_border_size": + var PlayToClientPacketParamsWorldBorderSizeTmp PlayToClientPacketWorldBorderSize + err = PlayToClientPacketParamsWorldBorderSizeTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsWorldBorderSizeTmp + case "world_border_warning_delay": + var PlayToClientPacketParamsWorldBorderWarningDelayTmp PlayToClientPacketWorldBorderWarningDelay + err = PlayToClientPacketParamsWorldBorderWarningDelayTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsWorldBorderWarningDelayTmp + case "world_border_warning_reach": + var PlayToClientPacketParamsWorldBorderWarningReachTmp PlayToClientPacketWorldBorderWarningReach + err = PlayToClientPacketParamsWorldBorderWarningReachTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsWorldBorderWarningReachTmp + case "world_event": + var PlayToClientPacketParamsWorldEventTmp PlayToClientPacketWorldEvent + err = PlayToClientPacketParamsWorldEventTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsWorldEventTmp + case "world_particles": + var PlayToClientPacketParamsWorldParticlesTmp PlayToClientPacketWorldParticles + err = PlayToClientPacketParamsWorldParticlesTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToClientPacketParamsWorldParticlesTmp + } + return +} + +var PlayToClientPacketNameReverseMap = map[string]int32{"bundle_delimiter": 0x00, "spawn_entity": 0x01, "animation": 0x02, "statistics": 0x03, "acknowledge_player_digging": 0x04, "block_break_animation": 0x05, "tile_entity_data": 0x06, "block_action": 0x07, "block_change": 0x08, "boss_bar": 0x09, "difficulty": 0x0a, "chunk_batch_finished": 0x0b, "chunk_batch_start": 0x0c, "chunk_biomes": 0x0d, "clear_titles": 0x0e, "tab_complete": 0x0f, "declare_commands": 0x10, "close_window": 0x11, "window_items": 0x12, "craft_progress_bar": 0x13, "set_slot": 0x14, "cookie_request": 0x15, "set_cooldown": 0x16, "chat_suggestions": 0x17, "custom_payload": 0x18, "damage_event": 0x19, "debug_sample": 0x1a, "hide_message": 0x1b, "kick_disconnect": 0x1c, "profileless_chat": 0x1d, "entity_status": 0x1e, "sync_entity_position": 0x1f, "explosion": 0x20, "unload_chunk": 0x21, "game_state_change": 0x22, "open_horse_window": 0x23, "hurt_animation": 0x24, "initialize_world_border": 0x25, "keep_alive": 0x26, "map_chunk": 0x27, "world_event": 0x28, "world_particles": 0x29, "update_light": 0x2a, "login": 0x2b, "map": 0x2c, "trade_list": 0x2d, "rel_entity_move": 0x2e, "entity_move_look": 0x2f, "move_minecart": 0x30, "entity_look": 0x31, "vehicle_move": 0x32, "open_book": 0x33, "open_window": 0x34, "open_sign_entity": 0x35, "ping": 0x36, "ping_response": 0x37, "craft_recipe_response": 0x38, "abilities": 0x39, "player_chat": 0x3a, "end_combat_event": 0x3b, "enter_combat_event": 0x3c, "death_combat_event": 0x3d, "player_remove": 0x3e, "player_info": 0x3f, "face_player": 0x40, "position": 0x41, "player_rotation": 0x42, "recipe_book_add": 0x43, "recipe_book_remove": 0x44, "recipe_book_settings": 0x45, "entity_destroy": 0x46, "remove_entity_effect": 0x47, "reset_score": 0x48, "remove_resource_pack": 0x49, "add_resource_pack": 0x4a, "respawn": 0x4b, "entity_head_rotation": 0x4c, "multi_block_change": 0x4d, "select_advancement_tab": 0x4e, "server_data": 0x4f, "action_bar": 0x50, "world_border_center": 0x51, "world_border_lerp_size": 0x52, "world_border_size": 0x53, "world_border_warning_delay": 0x54, "world_border_warning_reach": 0x55, "camera": 0x56, "update_view_position": 0x57, "update_view_distance": 0x58, "set_cursor_item": 0x59, "spawn_position": 0x5a, "scoreboard_display_objective": 0x5b, "entity_metadata": 0x5c, "attach_entity": 0x5d, "entity_velocity": 0x5e, "entity_equipment": 0x5f, "experience": 0x60, "update_health": 0x61, "held_item_slot": 0x62, "scoreboard_objective": 0x63, "set_passengers": 0x64, "set_player_inventory": 0x65, "teams": 0x66, "scoreboard_score": 0x67, "simulation_distance": 0x68, "set_title_subtitle": 0x69, "update_time": 0x6a, "set_title_text": 0x6b, "set_title_time": 0x6c, "entity_sound_effect": 0x6d, "sound_effect": 0x6e, "start_configuration": 0x6f, "stop_sound": 0x70, "store_cookie": 0x71, "system_chat": 0x72, "playerlist_header": 0x73, "nbt_query_response": 0x74, "collect": 0x75, "entity_teleport": 0x76, "test_instance_block_status": 0x77, "set_ticking_state": 0x78, "step_tick": 0x79, "transfer": 0x7a, "advancements": 0x7b, "entity_update_attributes": 0x7c, "entity_effect": 0x7d, "declare_recipes": 0x7e, "tags": 0x7f, "set_projectile_power": 0x80, "custom_report_details": 0x81, "server_links": 0x82, "tracked_waypoint": 0x83, "clear_dialog": 0x84, "show_dialog": 0x85} + +func (ret *PlayToClientPacket) Encode(w io.Writer) (err error) { + var vPlayToClientPacketName int32 + vPlayToClientPacketName, err = proto_base.ErroringIndex(PlayToClientPacketNameReverseMap, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketName) + if err != nil { + return + } + switch ret.Name { + case "abilities": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAbilities) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "acknowledge_player_digging": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAcknowledgePlayerDigging) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "action_bar": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketActionBar) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "add_resource_pack": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonAddResourcePack) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "advancements": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAdvancements) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "animation": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAnimation) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "attach_entity": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketAttachEntity) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "block_action": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockAction) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "block_break_animation": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockBreakAnimation) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "block_change": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBlockChange) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "boss_bar": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBossBar) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "bundle_delimiter": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketBundleDelimiter) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "camera": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCamera) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "chat_suggestions": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChatSuggestions) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "chunk_batch_finished": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBatchFinished) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "chunk_batch_start": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBatchStart) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "chunk_biomes": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketChunkBiomes) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "clear_dialog": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonClearDialog) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "clear_titles": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketClearTitles) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "close_window": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCloseWindow) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "collect": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCollect) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "cookie_request": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonCookieRequest) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "craft_progress_bar": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftProgressBar) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "craft_recipe_response": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCraftRecipeResponse) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "custom_payload": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCustomPayload) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "custom_report_details": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonCustomReportDetails) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "damage_event": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDamageEvent) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "death_combat_event": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeathCombatEvent) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "debug_sample": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDebugSample) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "declare_commands": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareCommands) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "declare_recipes": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDeclareRecipes) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "difficulty": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketDifficulty) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "end_combat_event": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEndCombatEvent) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "enter_combat_event": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEnterCombatEvent) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_destroy": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityDestroy) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_effect": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEffect) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_equipment": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityEquipment) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_head_rotation": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityHeadRotation) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_look": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityLook) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_metadata": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMetadata) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_move_look": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityMoveLook) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_sound_effect": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntitySoundEffect) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_status": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityStatus) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_teleport": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityTeleport) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_update_attributes": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityUpdateAttributes) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "entity_velocity": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketEntityVelocity) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "experience": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExperience) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "explosion": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketExplosion) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "face_player": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketFacePlayer) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "game_state_change": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketGameStateChange) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "held_item_slot": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHeldItemSlot) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "hide_message": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHideMessage) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "hurt_animation": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketHurtAnimation) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "initialize_world_border": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketInitializeWorldBorder) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "keep_alive": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKeepAlive) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "kick_disconnect": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketKickDisconnect) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "login": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketLogin) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "map": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMap) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "map_chunk": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMapChunk) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "move_minecart": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMoveMinecart) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "multi_block_change": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketMultiBlockChange) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "nbt_query_response": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketNbtQueryResponse) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "open_book": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenBook) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "open_horse_window": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenHorseWindow) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "open_sign_entity": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenSignEntity) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "open_window": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketOpenWindow) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "ping": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPing) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "ping_response": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPingResponse) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "player_chat": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerChat) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "player_info": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerInfo) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "player_remove": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerRemove) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "player_rotation": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerRotation) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "playerlist_header": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPlayerlistHeader) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "position": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketPosition) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "profileless_chat": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketProfilelessChat) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "recipe_book_add": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookAdd) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "recipe_book_remove": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookRemove) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "recipe_book_settings": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRecipeBookSettings) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "rel_entity_move": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRelEntityMove) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "remove_entity_effect": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRemoveEntityEffect) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "remove_resource_pack": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonRemoveResourcePack) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "reset_score": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketResetScore) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "respawn": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketRespawn) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "scoreboard_display_objective": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardDisplayObjective) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "scoreboard_objective": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardObjective) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "scoreboard_score": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketScoreboardScore) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "select_advancement_tab": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSelectAdvancementTab) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "server_data": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketServerData) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "server_links": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonServerLinks) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "set_cooldown": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCooldown) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "set_cursor_item": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetCursorItem) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "set_passengers": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPassengers) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "set_player_inventory": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetPlayerInventory) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "set_projectile_power": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetProjectilePower) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "set_slot": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetSlot) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "set_ticking_state": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTickingState) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "set_title_subtitle": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleSubtitle) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "set_title_text": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleText) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "set_title_time": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSetTitleTime) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "show_dialog": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketShowDialog) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "simulation_distance": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSimulationDistance) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "sound_effect": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSoundEffect) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "spawn_entity": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnEntity) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "spawn_position": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSpawnPosition) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "start_configuration": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStartConfiguration) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "statistics": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStatistics) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "step_tick": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStepTick) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "stop_sound": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketStopSound) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "store_cookie": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonStoreCookie) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "sync_entity_position": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSyncEntityPosition) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "system_chat": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketSystemChat) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "tab_complete": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTabComplete) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "tags": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTags) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "teams": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTeams) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "test_instance_block_status": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTestInstanceBlockStatus) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "tile_entity_data": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTileEntityData) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "tracked_waypoint": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTrackedWaypoint) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "trade_list": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketTradeList) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "transfer": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketCommonTransfer) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "unload_chunk": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUnloadChunk) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "update_health": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateHealth) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "update_light": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateLight) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "update_time": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateTime) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "update_view_distance": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewDistance) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "update_view_position": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketUpdateViewPosition) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "vehicle_move": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketVehicleMove) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "window_items": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWindowItems) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "world_border_center": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderCenter) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "world_border_lerp_size": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderLerpSize) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "world_border_size": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderSize) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "world_border_warning_delay": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderWarningDelay) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "world_border_warning_reach": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldBorderWarningReach) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "world_event": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldEvent) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + case "world_particles": + PlayToClientPacketParams, ok := ret.Params.(PlayToClientPacketWorldParticles) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketParams.Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketAbilities struct { + Flags int8 + FlyingSpeed float32 + WalkingSpeed float32 +} + +func (ret *PlayToClientPacketAbilities) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Flags) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.FlyingSpeed) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.WalkingSpeed) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketAbilities) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Flags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.FlyingSpeed) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.WalkingSpeed) + if err != nil { + return + } + return +} + +type PlayToClientPacketAcknowledgePlayerDigging struct { + SequenceId int32 +} + +func (ret *PlayToClientPacketAcknowledgePlayerDigging) Decode(r io.Reader) (err error) { + ret.SequenceId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketAcknowledgePlayerDigging) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.SequenceId) + if err != nil { + return + } + return +} + +type PlayToClientPacketActionBar struct { + Text nbt.Anon +} + +func (ret *PlayToClientPacketActionBar) Decode(r io.Reader) (err error) { + err = ret.Text.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketActionBar) Encode(w io.Writer) (err error) { + err = ret.Text.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketAdvancements struct { + Reset bool + AdvancementMapping []struct { + Key string + Value struct { + ParentId *string + DisplayData *struct { + Title nbt.Anon + Description nbt.Anon + Icon Slot + FrameType int32 + Flags uint32 + BackgroundTexture any + XCord float32 + YCord float32 + } + Requirements [][]string + SendsTelemtryData bool + } + } + Identifiers []string + ProgressMapping []struct { + Key string + Value []struct { + CriterionIdentifier string + CriterionProgress *int64 + } + } + ShowAdvancements bool +} + +func (ret *PlayToClientPacketAdvancements) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Reset) + if err != nil { + return + } + var lPlayToClientPacketAdvancementsAdvancementMapping int32 + lPlayToClientPacketAdvancementsAdvancementMapping, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.AdvancementMapping = []struct { + Key string + Value struct { + ParentId *string + DisplayData *struct { + Title nbt.Anon + Description nbt.Anon + Icon Slot + FrameType int32 + Flags uint32 + BackgroundTexture any + XCord float32 + YCord float32 + } + Requirements [][]string + SendsTelemtryData bool + } + }{} + for range lPlayToClientPacketAdvancementsAdvancementMapping { + var PlayToClientPacketAdvancementsAdvancementMappingElement struct { + Key string + Value struct { + ParentId *string + DisplayData *struct { + Title nbt.Anon + Description nbt.Anon + Icon Slot + FrameType int32 + Flags uint32 + BackgroundTexture any + XCord float32 + YCord float32 + } + Requirements [][]string + SendsTelemtryData bool + } + } + PlayToClientPacketAdvancementsAdvancementMappingElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent) + if err != nil { + return + } + if PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresent { + var PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue string + PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToClientPacketAdvancementsAdvancementMappingElement.Value.ParentId = &PlayToClientPacketAdvancementsAdvancementMappingElementValueParentIdPresentValue + } + var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent) + if err != nil { + return + } + if PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresent { + var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue struct { + Title nbt.Anon + Description nbt.Anon + Icon Slot + FrameType int32 + Flags uint32 + BackgroundTexture any + XCord float32 + YCord float32 + } + err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Title.Decode(r) + if err != nil { + return + } + err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Description.Decode(r) + if err != nil { + return + } + err = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Icon.Decode(r) + if err != nil { + return + } + PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.FrameType, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags) + if err != nil { + return + } + switch PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.Flags { + case 1: + var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp string + PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTexture1Tmp + default: + var PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp struct { + } + PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.BackgroundTexture = PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataBackgroundTextureTmp + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.XCord) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue.YCord) + if err != nil { + return + } + PlayToClientPacketAdvancementsAdvancementMappingElement.Value.DisplayData = &PlayToClientPacketAdvancementsAdvancementMappingElementValueDisplayDataPresentValue + } + var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements int32 + lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = [][]string{} + for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirements { + var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement []string + var lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement int32 + lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = []string{} + for range lPlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement { + var PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement string + PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement = append(PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElementElement) + } + PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements = append(PlayToClientPacketAdvancementsAdvancementMappingElement.Value.Requirements, PlayToClientPacketAdvancementsAdvancementMappingElementValueRequirementsElement) + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsAdvancementMappingElement.Value.SendsTelemtryData) + if err != nil { + return + } + ret.AdvancementMapping = append(ret.AdvancementMapping, PlayToClientPacketAdvancementsAdvancementMappingElement) + } + var lPlayToClientPacketAdvancementsIdentifiers int32 + lPlayToClientPacketAdvancementsIdentifiers, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Identifiers = []string{} + for range lPlayToClientPacketAdvancementsIdentifiers { + var PlayToClientPacketAdvancementsIdentifiersElement string + PlayToClientPacketAdvancementsIdentifiersElement, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Identifiers = append(ret.Identifiers, PlayToClientPacketAdvancementsIdentifiersElement) + } + var lPlayToClientPacketAdvancementsProgressMapping int32 + lPlayToClientPacketAdvancementsProgressMapping, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ProgressMapping = []struct { + Key string + Value []struct { + CriterionIdentifier string + CriterionProgress *int64 + } + }{} + for range lPlayToClientPacketAdvancementsProgressMapping { + var PlayToClientPacketAdvancementsProgressMappingElement struct { + Key string + Value []struct { + CriterionIdentifier string + CriterionProgress *int64 + } + } + PlayToClientPacketAdvancementsProgressMappingElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var lPlayToClientPacketAdvancementsProgressMappingElementValue int32 + lPlayToClientPacketAdvancementsProgressMappingElementValue, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketAdvancementsProgressMappingElement.Value = []struct { + CriterionIdentifier string + CriterionProgress *int64 + }{} + for range lPlayToClientPacketAdvancementsProgressMappingElementValue { + var PlayToClientPacketAdvancementsProgressMappingElementValueElement struct { + CriterionIdentifier string + CriterionProgress *int64 + } + PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionIdentifier, err = proto_base.DecodeString(r) + if err != nil { + return + } + var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent) + if err != nil { + return + } + if PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresent { + var PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue) + if err != nil { + return + } + PlayToClientPacketAdvancementsProgressMappingElementValueElement.CriterionProgress = &PlayToClientPacketAdvancementsProgressMappingElementValueElementCriterionProgressPresentValue + } + PlayToClientPacketAdvancementsProgressMappingElement.Value = append(PlayToClientPacketAdvancementsProgressMappingElement.Value, PlayToClientPacketAdvancementsProgressMappingElementValueElement) + } + ret.ProgressMapping = append(ret.ProgressMapping, PlayToClientPacketAdvancementsProgressMappingElement) + } + err = binary.Read(r, binary.BigEndian, &ret.ShowAdvancements) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketAdvancements) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Reset) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping))) + if err != nil { + return + } + for iPlayToClientPacketAdvancementsAdvancementMapping := range len(ret.AdvancementMapping) { + err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil) + if err != nil { + return + } + if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId != nil { + err = proto_base.EncodeString(w, *ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.ParentId) + if err != nil { + return + } + } + err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil) + if err != nil { + return + } + if ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData != nil { + err = (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Title.Encode(w) + if err != nil { + return + } + err = (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Description.Encode(w) + if err != nil { + return + } + err = (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Icon.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).FrameType) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags) + if err != nil { + return + } + switch (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).Flags { + case 1: + PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(string) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, PlayToClientPacketAdvancementsAdvancementMappingInnerValueDisplayDataBackgroundTexture) + if err != nil { + return + } + default: + _, ok := (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).BackgroundTexture.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).XCord) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, (*ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.DisplayData).YCord) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements))) + if err != nil { + return + } + for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements) { + err = proto_base.EncodeVarInt(w, int32(len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements]))) + if err != nil { + return + } + for iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner := range len(ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements]) { + err = proto_base.EncodeString(w, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.Requirements[iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirements][iPlayToClientPacketAdvancementsAdvancementMappingInnerValueRequirementsInner]) + if err != nil { + return + } + } + } + err = binary.Write(w, binary.BigEndian, ret.AdvancementMapping[iPlayToClientPacketAdvancementsAdvancementMapping].Value.SendsTelemtryData) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Identifiers))) + if err != nil { + return + } + for iPlayToClientPacketAdvancementsIdentifiers := range len(ret.Identifiers) { + err = proto_base.EncodeString(w, ret.Identifiers[iPlayToClientPacketAdvancementsIdentifiers]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping))) + if err != nil { + return + } + for iPlayToClientPacketAdvancementsProgressMapping := range len(ret.ProgressMapping) { + err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Key) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value))) + if err != nil { + return + } + for iPlayToClientPacketAdvancementsProgressMappingInnerValue := range len(ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value) { + err = proto_base.EncodeString(w, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionIdentifier) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil) + if err != nil { + return + } + if ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress != nil { + err = binary.Write(w, binary.BigEndian, *ret.ProgressMapping[iPlayToClientPacketAdvancementsProgressMapping].Value[iPlayToClientPacketAdvancementsProgressMappingInnerValue].CriterionProgress) + if err != nil { + return + } + } + } + } + err = binary.Write(w, binary.BigEndian, ret.ShowAdvancements) + if err != nil { + return + } + return +} + +type PlayToClientPacketAnimation struct { + EntityId int32 + Animation uint8 +} + +func (ret *PlayToClientPacketAnimation) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Animation) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketAnimation) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Animation) + if err != nil { + return + } + return +} + +type PlayToClientPacketAttachEntity struct { + EntityId int32 + VehicleId int32 +} + +func (ret *PlayToClientPacketAttachEntity) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.EntityId) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.VehicleId) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketAttachEntity) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.VehicleId) + if err != nil { + return + } + return +} + +type PlayToClientPacketBlockAction struct { + Location Position + Byte1 uint8 + Byte2 uint8 + BlockId int32 +} + +func (ret *PlayToClientPacketBlockAction) Decode(r io.Reader) (err error) { + err = ret.Location.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Byte1) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Byte2) + if err != nil { + return + } + ret.BlockId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketBlockAction) Encode(w io.Writer) (err error) { + err = ret.Location.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Byte1) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Byte2) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.BlockId) + if err != nil { + return + } + return +} + +type PlayToClientPacketBlockBreakAnimation struct { + EntityId int32 + Location Position + DestroyStage int8 +} + +func (ret *PlayToClientPacketBlockBreakAnimation) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.Location.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.DestroyStage) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketBlockBreakAnimation) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = ret.Location.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.DestroyStage) + if err != nil { + return + } + return +} + +type PlayToClientPacketBlockChange struct { + Location Position + Type int32 +} + +func (ret *PlayToClientPacketBlockChange) Decode(r io.Reader) (err error) { + err = ret.Location.Decode(r) + if err != nil { + return + } + ret.Type, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketBlockChange) Encode(w io.Writer) (err error) { + err = ret.Location.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Type) + if err != nil { + return + } + return +} + +type PlayToClientPacketBossBar struct { + EntityUUID uuid.UUID + Action int32 + Title any + Health any + Color any + Dividers any + Flags any +} + +func (ret *PlayToClientPacketBossBar) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.EntityUUID[:]) + if err != nil { + return + } + ret.Action, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + switch ret.Action { + case 0: + var PlayToClientPacketBossBarTitle0Tmp nbt.Anon + err = PlayToClientPacketBossBarTitle0Tmp.Decode(r) + if err != nil { + return + } + ret.Title = PlayToClientPacketBossBarTitle0Tmp + case 3: + var PlayToClientPacketBossBarTitle3Tmp nbt.Anon + err = PlayToClientPacketBossBarTitle3Tmp.Decode(r) + if err != nil { + return + } + ret.Title = PlayToClientPacketBossBarTitle3Tmp + default: + var PlayToClientPacketBossBarTitleTmp struct { + } + ret.Title = PlayToClientPacketBossBarTitleTmp + } + switch ret.Action { + case 0: + var PlayToClientPacketBossBarHealth0Tmp float32 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth0Tmp) + if err != nil { + return + } + ret.Health = PlayToClientPacketBossBarHealth0Tmp + case 2: + var PlayToClientPacketBossBarHealth2Tmp float32 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarHealth2Tmp) + if err != nil { + return + } + ret.Health = PlayToClientPacketBossBarHealth2Tmp + default: + var PlayToClientPacketBossBarHealthTmp struct { + } + ret.Health = PlayToClientPacketBossBarHealthTmp + } + switch ret.Action { + case 0: + var PlayToClientPacketBossBarColor0Tmp int32 + PlayToClientPacketBossBarColor0Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Color = PlayToClientPacketBossBarColor0Tmp + case 4: + var PlayToClientPacketBossBarColor4Tmp int32 + PlayToClientPacketBossBarColor4Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Color = PlayToClientPacketBossBarColor4Tmp + default: + var PlayToClientPacketBossBarColorTmp struct { + } + ret.Color = PlayToClientPacketBossBarColorTmp + } + switch ret.Action { + case 0: + var PlayToClientPacketBossBarDividers0Tmp int32 + PlayToClientPacketBossBarDividers0Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Dividers = PlayToClientPacketBossBarDividers0Tmp + case 4: + var PlayToClientPacketBossBarDividers4Tmp int32 + PlayToClientPacketBossBarDividers4Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Dividers = PlayToClientPacketBossBarDividers4Tmp + default: + var PlayToClientPacketBossBarDividersTmp struct { + } + ret.Dividers = PlayToClientPacketBossBarDividersTmp + } + switch ret.Action { + case 0: + var PlayToClientPacketBossBarFlags0Tmp uint8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags0Tmp) + if err != nil { + return + } + ret.Flags = PlayToClientPacketBossBarFlags0Tmp + case 5: + var PlayToClientPacketBossBarFlags5Tmp uint8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketBossBarFlags5Tmp) + if err != nil { + return + } + ret.Flags = PlayToClientPacketBossBarFlags5Tmp + default: + var PlayToClientPacketBossBarFlagsTmp struct { + } + ret.Flags = PlayToClientPacketBossBarFlagsTmp + } + return +} +func (ret *PlayToClientPacketBossBar) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.EntityUUID[:]) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Action) + if err != nil { + return + } + switch ret.Action { + case 0: + PlayToClientPacketBossBarTitle, ok := ret.Title.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketBossBarTitle.Encode(w) + if err != nil { + return + } + case 3: + PlayToClientPacketBossBarTitle, ok := ret.Title.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketBossBarTitle.Encode(w) + if err != nil { + return + } + default: + _, ok := ret.Title.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action { + case 0: + PlayToClientPacketBossBarHealth, ok := ret.Health.(float32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth) + if err != nil { + return + } + case 2: + PlayToClientPacketBossBarHealth, ok := ret.Health.(float32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarHealth) + if err != nil { + return + } + default: + _, ok := ret.Health.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action { + case 0: + PlayToClientPacketBossBarColor, ok := ret.Color.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor) + if err != nil { + return + } + case 4: + PlayToClientPacketBossBarColor, ok := ret.Color.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarColor) + if err != nil { + return + } + default: + _, ok := ret.Color.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action { + case 0: + PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers) + if err != nil { + return + } + case 4: + PlayToClientPacketBossBarDividers, ok := ret.Dividers.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketBossBarDividers) + if err != nil { + return + } + default: + _, ok := ret.Dividers.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action { + case 0: + PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags) + if err != nil { + return + } + case 5: + PlayToClientPacketBossBarFlags, ok := ret.Flags.(uint8) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketBossBarFlags) + if err != nil { + return + } + default: + _, ok := ret.Flags.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + return +} + +type PlayToClientPacketBundleDelimiter struct { +} + +func (ret *PlayToClientPacketBundleDelimiter) Decode(r io.Reader) (err error) { + return +} +func (ret *PlayToClientPacketBundleDelimiter) Encode(w io.Writer) (err error) { + return +} + +type PlayToClientPacketCamera struct { + CameraId int32 +} + +func (ret *PlayToClientPacketCamera) Decode(r io.Reader) (err error) { + ret.CameraId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketCamera) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.CameraId) + if err != nil { + return + } + return +} + +type PlayToClientPacketChatSuggestions struct { + Action int32 + Entries []string +} + +func (ret *PlayToClientPacketChatSuggestions) Decode(r io.Reader) (err error) { + ret.Action, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lPlayToClientPacketChatSuggestionsEntries int32 + lPlayToClientPacketChatSuggestionsEntries, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Entries = []string{} + for range lPlayToClientPacketChatSuggestionsEntries { + var PlayToClientPacketChatSuggestionsEntriesElement string + PlayToClientPacketChatSuggestionsEntriesElement, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Entries = append(ret.Entries, PlayToClientPacketChatSuggestionsEntriesElement) + } + return +} +func (ret *PlayToClientPacketChatSuggestions) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Action) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Entries))) + if err != nil { + return + } + for iPlayToClientPacketChatSuggestionsEntries := range len(ret.Entries) { + err = proto_base.EncodeString(w, ret.Entries[iPlayToClientPacketChatSuggestionsEntries]) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketChunkBatchFinished struct { + BatchSize int32 +} + +func (ret *PlayToClientPacketChunkBatchFinished) Decode(r io.Reader) (err error) { + ret.BatchSize, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketChunkBatchFinished) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.BatchSize) + if err != nil { + return + } + return +} + +type PlayToClientPacketChunkBatchStart struct { +} + +func (ret *PlayToClientPacketChunkBatchStart) Decode(r io.Reader) (err error) { + return +} +func (ret *PlayToClientPacketChunkBatchStart) Encode(w io.Writer) (err error) { + return +} + +type PlayToClientPacketChunkBiomes struct { + Biomes []struct { + Position PackedChunkPos + Data ByteArray + } +} + +func (ret *PlayToClientPacketChunkBiomes) Decode(r io.Reader) (err error) { + var lPlayToClientPacketChunkBiomesBiomes int32 + lPlayToClientPacketChunkBiomesBiomes, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Biomes = []struct { + Position PackedChunkPos + Data ByteArray + }{} + for range lPlayToClientPacketChunkBiomesBiomes { + var PlayToClientPacketChunkBiomesBiomesElement struct { + Position PackedChunkPos + Data ByteArray + } + err = PlayToClientPacketChunkBiomesBiomesElement.Position.Decode(r) + if err != nil { + return + } + err = PlayToClientPacketChunkBiomesBiomesElement.Data.Decode(r) + if err != nil { + return + } + ret.Biomes = append(ret.Biomes, PlayToClientPacketChunkBiomesBiomesElement) + } + return +} +func (ret *PlayToClientPacketChunkBiomes) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Biomes))) + if err != nil { + return + } + for iPlayToClientPacketChunkBiomesBiomes := range len(ret.Biomes) { + err = ret.Biomes[iPlayToClientPacketChunkBiomesBiomes].Position.Encode(w) + if err != nil { + return + } + err = ret.Biomes[iPlayToClientPacketChunkBiomesBiomes].Data.Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketClearTitles struct { + Reset bool +} + +func (ret *PlayToClientPacketClearTitles) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Reset) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketClearTitles) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Reset) + if err != nil { + return + } + return +} + +type PlayToClientPacketCloseWindow struct { + WindowId ContainerID +} + +func (ret *PlayToClientPacketCloseWindow) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketCloseWindow) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketCollect struct { + CollectedEntityId int32 + CollectorEntityId int32 + PickupItemCount int32 +} + +func (ret *PlayToClientPacketCollect) Decode(r io.Reader) (err error) { + ret.CollectedEntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.CollectorEntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.PickupItemCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketCollect) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.CollectedEntityId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.CollectorEntityId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.PickupItemCount) + if err != nil { + return + } + return +} + +type PlayToClientPacketCommonAddResourcePack struct { + Uuid uuid.UUID + Url string + Hash string + Forced bool + PromptMessage *nbt.Anon +} + +func (ret *PlayToClientPacketCommonAddResourcePack) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Url, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Hash, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Forced) + if err != nil { + return + } + var PlayToClientPacketCommonAddResourcePackPromptMessagePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonAddResourcePackPromptMessagePresent) + if err != nil { + return + } + if PlayToClientPacketCommonAddResourcePackPromptMessagePresent { + var PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon + err = PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.PromptMessage = &PlayToClientPacketCommonAddResourcePackPromptMessagePresentValue + } + return +} +func (ret *PlayToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Url) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Hash) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Forced) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) + if err != nil { + return + } + if ret.PromptMessage != nil { + err = (*ret.PromptMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketCommonClearDialog struct { +} + +func (ret *PlayToClientPacketCommonClearDialog) Decode(r io.Reader) (err error) { + return +} +func (ret *PlayToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) { + return +} + +type PlayToClientPacketCommonCookieRequest struct { + Cookie string +} + +func (ret *PlayToClientPacketCommonCookieRequest) Decode(r io.Reader) (err error) { + ret.Cookie, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Cookie) + if err != nil { + return + } + return +} + +type PlayToClientPacketCommonCookieResponse struct { + Key string + Value *ByteArray +} + +func (ret *PlayToClientPacketCommonCookieResponse) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var PlayToClientPacketCommonCookieResponseValuePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonCookieResponseValuePresent) + if err != nil { + return + } + if PlayToClientPacketCommonCookieResponseValuePresent { + var PlayToClientPacketCommonCookieResponseValuePresentValue ByteArray + err = PlayToClientPacketCommonCookieResponseValuePresentValue.Decode(r) + if err != nil { + return + } + ret.Value = &PlayToClientPacketCommonCookieResponseValuePresentValue + } + return +} +func (ret *PlayToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value != nil) + if err != nil { + return + } + if ret.Value != nil { + err = (*ret.Value).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketCommonCustomClickAction struct { + Id string + Nbt *nbt.Anon +} + +func (ret *PlayToClientPacketCommonCustomClickAction) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var PlayToClientPacketCommonCustomClickActionNbtPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonCustomClickActionNbtPresent) + if err != nil { + return + } + if PlayToClientPacketCommonCustomClickActionNbtPresent { + var PlayToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon + err = PlayToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r) + if err != nil { + return + } + ret.Nbt = &PlayToClientPacketCommonCustomClickActionNbtPresentValue + } + return +} +func (ret *PlayToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) + if err != nil { + return + } + if ret.Nbt != nil { + err = (*ret.Nbt).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketCommonCustomReportDetails struct { + Details []struct { + Key string + Value string + } +} + +func (ret *PlayToClientPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) { + var lPlayToClientPacketCommonCustomReportDetailsDetails int32 + lPlayToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Details = []struct { + Key string + Value string + }{} + for range lPlayToClientPacketCommonCustomReportDetailsDetails { + var PlayToClientPacketCommonCustomReportDetailsDetailsElement struct { + Key string + Value string + } + PlayToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Details = append(ret.Details, PlayToClientPacketCommonCustomReportDetailsDetailsElement) + } + return +} +func (ret *PlayToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) + if err != nil { + return + } + for iPlayToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) { + err = proto_base.EncodeString(w, ret.Details[iPlayToClientPacketCommonCustomReportDetailsDetails].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Details[iPlayToClientPacketCommonCustomReportDetailsDetails].Value) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketCommonRemoveResourcePack struct { + Uuid *uuid.UUID +} + +func (ret *PlayToClientPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) { + var PlayToClientPacketCommonRemoveResourcePackUuidPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonRemoveResourcePackUuidPresent) + if err != nil { + return + } + if PlayToClientPacketCommonRemoveResourcePackUuidPresent { + var PlayToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID + _, err = io.ReadFull(r, PlayToClientPacketCommonRemoveResourcePackUuidPresentValue[:]) + if err != nil { + return + } + ret.Uuid = &PlayToClientPacketCommonRemoveResourcePackUuidPresentValue + } + return +} +func (ret *PlayToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) + if err != nil { + return + } + if ret.Uuid != nil { + _, err = w.Write((*ret.Uuid)[:]) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketCommonSelectKnownPacks struct { + Packs []struct { + Namespace string + Id string + Version string + } +} + +func (ret *PlayToClientPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) { + var lPlayToClientPacketCommonSelectKnownPacksPacks int32 + lPlayToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Packs = []struct { + Namespace string + Id string + Version string + }{} + for range lPlayToClientPacketCommonSelectKnownPacksPacks { + var PlayToClientPacketCommonSelectKnownPacksPacksElement struct { + Namespace string + Id string + Version string + } + PlayToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Packs = append(ret.Packs, PlayToClientPacketCommonSelectKnownPacksPacksElement) + } + return +} +func (ret *PlayToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) + if err != nil { + return + } + for iPlayToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { + err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Namespace) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Id) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iPlayToClientPacketCommonSelectKnownPacksPacks].Version) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketCommonServerLinks struct { + Links []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } +} + +func (ret *PlayToClientPacketCommonServerLinks) Decode(r io.Reader) (err error) { + var lPlayToClientPacketCommonServerLinksLinks int32 + lPlayToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Links = []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + }{} + for range lPlayToClientPacketCommonServerLinksLinks { + var PlayToClientPacketCommonServerLinksLinksElement struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketCommonServerLinksLinksElement.HasKnownType) + if err != nil { + return + } + switch PlayToClientPacketCommonServerLinksLinksElement.HasKnownType { + case true: + var PlayToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType + err = PlayToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) + if err != nil { + return + } + PlayToClientPacketCommonServerLinksLinksElement.KnownType = PlayToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp + } + switch PlayToClientPacketCommonServerLinksLinksElement.HasKnownType { + case false: + var PlayToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon + err = PlayToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) + if err != nil { + return + } + PlayToClientPacketCommonServerLinksLinksElement.UnknownType = PlayToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp + } + PlayToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Links = append(ret.Links, PlayToClientPacketCommonServerLinksLinksElement) + } + return +} +func (ret *PlayToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) + if err != nil { + return + } + for iPlayToClientPacketCommonServerLinksLinks := range len(ret.Links) { + err = binary.Write(w, binary.BigEndian, ret.Links[iPlayToClientPacketCommonServerLinksLinks].HasKnownType) + if err != nil { + return + } + switch ret.Links[iPlayToClientPacketCommonServerLinksLinks].HasKnownType { + case true: + PlayToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iPlayToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketCommonServerLinksLinksInnerKnownType.Encode(w) + if err != nil { + return + } + } + switch ret.Links[iPlayToClientPacketCommonServerLinksLinks].HasKnownType { + case false: + PlayToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iPlayToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketCommonServerLinksLinksInnerUnknownType.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Links[iPlayToClientPacketCommonServerLinksLinks].Link) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketCommonSettings struct { + Locale string + ViewDistance int8 + ChatFlags int32 + ChatColors bool + SkinParts uint8 + MainHand int32 + EnableTextFiltering bool + EnableServerListing bool + ParticleStatus string +} + +var PlayToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} + +func (ret *PlayToClientPacketCommonSettings) Decode(r io.Reader) (err error) { + ret.Locale, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ViewDistance) + if err != nil { + return + } + ret.ChatFlags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChatColors) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SkinParts) + if err != nil { + return + } + ret.MainHand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) + if err != nil { + return + } + var PlayToClientPacketCommonSettingsParticleStatusKey int32 + PlayToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ParticleStatus, err = proto_base.ErroringIndex(PlayToClientPacketCommonSettingsParticleStatusMap, PlayToClientPacketCommonSettingsParticleStatusKey) + if err != nil { + return + } + return +} + +var PlayToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} + +func (ret *PlayToClientPacketCommonSettings) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Locale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChatFlags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChatColors) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SkinParts) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.MainHand) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) + if err != nil { + return + } + var vPlayToClientPacketCommonSettingsParticleStatus int32 + vPlayToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(PlayToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketCommonSettingsParticleStatus) + if err != nil { + return + } + return +} + +type PlayToClientPacketCommonStoreCookie struct { + Key string + Value ByteArray +} + +func (ret *PlayToClientPacketCommonStoreCookie) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Value.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = ret.Value.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketCommonTransfer struct { + Host string + Port int32 +} + +func (ret *PlayToClientPacketCommonTransfer) Decode(r io.Reader) (err error) { + ret.Host, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Port, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketCommonTransfer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Host) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Port) + if err != nil { + return + } + return +} + +type PlayToClientPacketCraftProgressBar struct { + WindowId ContainerID + Property int16 + Value int16 +} + +func (ret *PlayToClientPacketCraftProgressBar) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Property) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Value) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketCraftProgressBar) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Property) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value) + if err != nil { + return + } + return +} + +type PlayToClientPacketCraftRecipeResponse struct { + WindowId ContainerID + RecipeDisplay PlayToClientRecipeDisplay +} + +func (ret *PlayToClientPacketCraftRecipeResponse) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + err = ret.RecipeDisplay.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketCraftRecipeResponse) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + err = ret.RecipeDisplay.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketCustomPayload struct { + Channel string + Data proto_base.RestBuffer +} + +func (ret *PlayToClientPacketCustomPayload) Decode(r io.Reader) (err error) { + ret.Channel, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Data.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketCustomPayload) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Channel) + if err != nil { + return + } + err = ret.Data.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketDamageEvent struct { + EntityId int32 + SourceTypeId int32 + SourceCauseId int32 + SourceDirectId int32 + SourcePosition *Vec3f64 +} + +func (ret *PlayToClientPacketDamageEvent) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SourceTypeId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SourceCauseId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SourceDirectId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var PlayToClientPacketDamageEventSourcePositionPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketDamageEventSourcePositionPresent) + if err != nil { + return + } + if PlayToClientPacketDamageEventSourcePositionPresent { + var PlayToClientPacketDamageEventSourcePositionPresentValue Vec3f64 + err = PlayToClientPacketDamageEventSourcePositionPresentValue.Decode(r) + if err != nil { + return + } + ret.SourcePosition = &PlayToClientPacketDamageEventSourcePositionPresentValue + } + return +} +func (ret *PlayToClientPacketDamageEvent) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.SourceTypeId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.SourceCauseId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.SourceDirectId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SourcePosition != nil) + if err != nil { + return + } + if ret.SourcePosition != nil { + err = (*ret.SourcePosition).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketDeathCombatEvent struct { + PlayerId int32 + Message nbt.Anon +} + +func (ret *PlayToClientPacketDeathCombatEvent) Decode(r io.Reader) (err error) { + ret.PlayerId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.Message.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketDeathCombatEvent) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.PlayerId) + if err != nil { + return + } + err = ret.Message.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketDebugSample struct { + Sample []int64 + Type int32 +} + +func (ret *PlayToClientPacketDebugSample) Decode(r io.Reader) (err error) { + var lPlayToClientPacketDebugSampleSample int32 + lPlayToClientPacketDebugSampleSample, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Sample = []int64{} + for range lPlayToClientPacketDebugSampleSample { + var PlayToClientPacketDebugSampleSampleElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketDebugSampleSampleElement) + if err != nil { + return + } + ret.Sample = append(ret.Sample, PlayToClientPacketDebugSampleSampleElement) + } + ret.Type, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketDebugSample) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Sample))) + if err != nil { + return + } + for iPlayToClientPacketDebugSampleSample := range len(ret.Sample) { + err = binary.Write(w, binary.BigEndian, ret.Sample[iPlayToClientPacketDebugSampleSample]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, ret.Type) + if err != nil { + return + } + return +} + +type PlayToClientPacketDeclareCommands struct { + Nodes []CommandNode + RootIndex int32 +} + +func (ret *PlayToClientPacketDeclareCommands) Decode(r io.Reader) (err error) { + var lPlayToClientPacketDeclareCommandsNodes int32 + lPlayToClientPacketDeclareCommandsNodes, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Nodes = []CommandNode{} + for range lPlayToClientPacketDeclareCommandsNodes { + var PlayToClientPacketDeclareCommandsNodesElement CommandNode + err = PlayToClientPacketDeclareCommandsNodesElement.Decode(r) + if err != nil { + return + } + ret.Nodes = append(ret.Nodes, PlayToClientPacketDeclareCommandsNodesElement) + } + ret.RootIndex, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketDeclareCommands) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Nodes))) + if err != nil { + return + } + for iPlayToClientPacketDeclareCommandsNodes := range len(ret.Nodes) { + err = ret.Nodes[iPlayToClientPacketDeclareCommandsNodes].Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, ret.RootIndex) + if err != nil { + return + } + return +} + +type PlayToClientPacketDeclareRecipes struct { + Recipes []struct { + Name string + Items []int32 + } + StoneCutterRecipes []struct { + Input IDSet + SlotDisplay PlayToClientSlotDisplay + } +} + +func (ret *PlayToClientPacketDeclareRecipes) Decode(r io.Reader) (err error) { + var lPlayToClientPacketDeclareRecipesRecipes int32 + lPlayToClientPacketDeclareRecipesRecipes, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Recipes = []struct { + Name string + Items []int32 + }{} + for range lPlayToClientPacketDeclareRecipesRecipes { + var PlayToClientPacketDeclareRecipesRecipesElement struct { + Name string + Items []int32 + } + PlayToClientPacketDeclareRecipesRecipesElement.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + var lPlayToClientPacketDeclareRecipesRecipesElementItems int32 + lPlayToClientPacketDeclareRecipesRecipesElementItems, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketDeclareRecipesRecipesElement.Items = []int32{} + for range lPlayToClientPacketDeclareRecipesRecipesElementItems { + var PlayToClientPacketDeclareRecipesRecipesElementItemsElement int32 + PlayToClientPacketDeclareRecipesRecipesElementItemsElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketDeclareRecipesRecipesElement.Items = append(PlayToClientPacketDeclareRecipesRecipesElement.Items, PlayToClientPacketDeclareRecipesRecipesElementItemsElement) + } + ret.Recipes = append(ret.Recipes, PlayToClientPacketDeclareRecipesRecipesElement) + } + var lPlayToClientPacketDeclareRecipesStoneCutterRecipes int32 + lPlayToClientPacketDeclareRecipesStoneCutterRecipes, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.StoneCutterRecipes = []struct { + Input IDSet + SlotDisplay PlayToClientSlotDisplay + }{} + for range lPlayToClientPacketDeclareRecipesStoneCutterRecipes { + var PlayToClientPacketDeclareRecipesStoneCutterRecipesElement struct { + Input IDSet + SlotDisplay PlayToClientSlotDisplay + } + err = PlayToClientPacketDeclareRecipesStoneCutterRecipesElement.Input.Decode(r) + if err != nil { + return + } + err = PlayToClientPacketDeclareRecipesStoneCutterRecipesElement.SlotDisplay.Decode(r) + if err != nil { + return + } + ret.StoneCutterRecipes = append(ret.StoneCutterRecipes, PlayToClientPacketDeclareRecipesStoneCutterRecipesElement) + } + return +} +func (ret *PlayToClientPacketDeclareRecipes) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes))) + if err != nil { + return + } + for iPlayToClientPacketDeclareRecipesRecipes := range len(ret.Recipes) { + err = proto_base.EncodeString(w, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items))) + if err != nil { + return + } + for iPlayToClientPacketDeclareRecipesRecipesInnerItems := range len(ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items) { + err = proto_base.EncodeVarInt(w, ret.Recipes[iPlayToClientPacketDeclareRecipesRecipes].Items[iPlayToClientPacketDeclareRecipesRecipesInnerItems]) + if err != nil { + return + } + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.StoneCutterRecipes))) + if err != nil { + return + } + for iPlayToClientPacketDeclareRecipesStoneCutterRecipes := range len(ret.StoneCutterRecipes) { + err = ret.StoneCutterRecipes[iPlayToClientPacketDeclareRecipesStoneCutterRecipes].Input.Encode(w) + if err != nil { + return + } + err = ret.StoneCutterRecipes[iPlayToClientPacketDeclareRecipesStoneCutterRecipes].SlotDisplay.Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketDifficulty struct { + Difficulty string + DifficultyLocked bool +} + +var PlayToClientPacketDifficultyDifficultyMap = map[int32]string{0: "peaceful", 1: "easy", 2: "normal", 3: "hard"} + +func (ret *PlayToClientPacketDifficulty) Decode(r io.Reader) (err error) { + var PlayToClientPacketDifficultyDifficultyKey int32 + PlayToClientPacketDifficultyDifficultyKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Difficulty, err = proto_base.ErroringIndex(PlayToClientPacketDifficultyDifficultyMap, PlayToClientPacketDifficultyDifficultyKey) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.DifficultyLocked) + if err != nil { + return + } + return +} + +var PlayToClientPacketDifficultyDifficultyReverseMap = map[string]int32{"peaceful": 0, "easy": 1, "normal": 2, "hard": 3} + +func (ret *PlayToClientPacketDifficulty) Encode(w io.Writer) (err error) { + var vPlayToClientPacketDifficultyDifficulty int32 + vPlayToClientPacketDifficultyDifficulty, err = proto_base.ErroringIndex(PlayToClientPacketDifficultyDifficultyReverseMap, ret.Difficulty) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketDifficultyDifficulty) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.DifficultyLocked) + if err != nil { + return + } + return +} + +type PlayToClientPacketEndCombatEvent struct { + Duration int32 +} + +func (ret *PlayToClientPacketEndCombatEvent) Decode(r io.Reader) (err error) { + ret.Duration, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketEndCombatEvent) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Duration) + if err != nil { + return + } + return +} + +type PlayToClientPacketEnterCombatEvent struct { +} + +func (ret *PlayToClientPacketEnterCombatEvent) Decode(r io.Reader) (err error) { + return +} +func (ret *PlayToClientPacketEnterCombatEvent) Encode(w io.Writer) (err error) { + return +} + +type PlayToClientPacketEntityDestroy struct { + EntityIds []int32 +} + +func (ret *PlayToClientPacketEntityDestroy) Decode(r io.Reader) (err error) { + var lPlayToClientPacketEntityDestroyEntityIds int32 + lPlayToClientPacketEntityDestroyEntityIds, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EntityIds = []int32{} + for range lPlayToClientPacketEntityDestroyEntityIds { + var PlayToClientPacketEntityDestroyEntityIdsElement int32 + PlayToClientPacketEntityDestroyEntityIdsElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EntityIds = append(ret.EntityIds, PlayToClientPacketEntityDestroyEntityIdsElement) + } + return +} +func (ret *PlayToClientPacketEntityDestroy) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.EntityIds))) + if err != nil { + return + } + for iPlayToClientPacketEntityDestroyEntityIds := range len(ret.EntityIds) { + err = proto_base.EncodeVarInt(w, ret.EntityIds[iPlayToClientPacketEntityDestroyEntityIds]) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketEntityEffect struct { + EntityId int32 + EffectId int32 + Amplifier int32 + Duration int32 + Flags uint8 +} + +func (ret *PlayToClientPacketEntityEffect) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EffectId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Amplifier, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Duration, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Flags) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketEntityEffect) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.EffectId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Amplifier) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Duration) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Flags) + if err != nil { + return + } + return +} + +type PlayToClientPacketEntityEquipment struct { + Val proto_base.ToDo +} + +func (ret *PlayToClientPacketEntityEquipment) Decode(r io.Reader) (err error) { + err = proto_base.ToDoError + return +} +func (ret *PlayToClientPacketEntityEquipment) Encode(w io.Writer) (err error) { + err = proto_base.ToDoError + return +} + +type PlayToClientPacketEntityHeadRotation struct { + EntityId int32 + HeadYaw int8 +} + +func (ret *PlayToClientPacketEntityHeadRotation) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.HeadYaw) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketEntityHeadRotation) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.HeadYaw) + if err != nil { + return + } + return +} + +type PlayToClientPacketEntityLook struct { + EntityId int32 + Yaw int8 + Pitch int8 + OnGround bool +} + +func (ret *PlayToClientPacketEntityLook) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OnGround) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketEntityLook) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OnGround) + if err != nil { + return + } + return +} + +type PlayToClientPacketEntityMetadata struct { + EntityId int32 + Metadata EntityMetadata +} + +func (ret *PlayToClientPacketEntityMetadata) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.Metadata.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketEntityMetadata) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = ret.Metadata.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketEntityMoveLook struct { + EntityId int32 + DX int16 + DY int16 + DZ int16 + Yaw int8 + Pitch int8 + OnGround bool +} + +func (ret *PlayToClientPacketEntityMoveLook) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.DX) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.DY) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.DZ) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OnGround) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketEntityMoveLook) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.DX) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.DY) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.DZ) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OnGround) + if err != nil { + return + } + return +} + +type PlayToClientPacketEntitySoundEffect struct { + Sound ItemSoundHolder + SoundCategory SoundSource + EntityId int32 + Volume float32 + Pitch float32 + Seed int64 +} + +func (ret *PlayToClientPacketEntitySoundEffect) Decode(r io.Reader) (err error) { + err = ret.Sound.Decode(r) + if err != nil { + return + } + err = ret.SoundCategory.Decode(r) + if err != nil { + return + } + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Volume) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Seed) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketEntitySoundEffect) Encode(w io.Writer) (err error) { + err = ret.Sound.Encode(w) + if err != nil { + return + } + err = ret.SoundCategory.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Volume) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Seed) + if err != nil { + return + } + return +} + +type PlayToClientPacketEntityStatus struct { + EntityId int32 + EntityStatus int8 +} + +func (ret *PlayToClientPacketEntityStatus) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.EntityId) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EntityStatus) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketEntityStatus) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EntityStatus) + if err != nil { + return + } + return +} + +type PlayToClientPacketEntityTeleport struct { + EntityId int32 + X float64 + Y float64 + Z float64 + Yaw int8 + Pitch int8 + OnGround bool +} + +func (ret *PlayToClientPacketEntityTeleport) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OnGround) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketEntityTeleport) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OnGround) + if err != nil { + return + } + return +} + +type PlayToClientPacketEntityUpdateAttributes struct { + EntityId int32 + Properties []struct { + Key string + Value float64 + Modifiers []struct { + Uuid string + Amount float64 + Operation int8 + } + } +} + +var PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyMap = map[int32]string{0: "generic.armor", 1: "generic.armor_toughness", 10: "player.entity_interaction_range", 11: "generic.fall_damage_multiplier", 12: "generic.flying_speed", 13: "generic.follow_range", 14: "generic.gravity", 15: "generic.jump_strength", 16: "generic.knockback_resistance", 17: "generic.luck", 18: "generic.max_absorption", 19: "generic.max_health", 2: "generic.attack_damage", 20: "generic.movement_speed", 21: "generic.safe_fall_distance", 22: "generic.scale", 23: "zombie.spawn_reinforcements", 24: "generic.step_height", 25: "submerged_mining_speed", 26: "sweeping_damage_ratio", 27: "tempt_range", 28: "water_movement_efficiency", 29: "waypoint_transmit_range", 3: "generic.attack_knockback", 30: "waypoint_receive_range", 4: "generic.attack_speed", 5: "player.block_break_speed", 6: "player.block_interaction_range", 7: "burning_time", 8: "camera_distance", 9: "explosion_knockback_resistance"} + +func (ret *PlayToClientPacketEntityUpdateAttributes) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lPlayToClientPacketEntityUpdateAttributesProperties int32 + lPlayToClientPacketEntityUpdateAttributesProperties, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Properties = []struct { + Key string + Value float64 + Modifiers []struct { + Uuid string + Amount float64 + Operation int8 + } + }{} + for range lPlayToClientPacketEntityUpdateAttributesProperties { + var PlayToClientPacketEntityUpdateAttributesPropertiesElement struct { + Key string + Value float64 + Modifiers []struct { + Uuid string + Amount float64 + Operation int8 + } + } + var PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey int32 + PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketEntityUpdateAttributesPropertiesElement.Key, err = proto_base.ErroringIndex(PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyMap, PlayToClientPacketEntityUpdateAttributesPropertiesElementKeyKey) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElement.Value) + if err != nil { + return + } + var lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers int32 + lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers = []struct { + Uuid string + Amount float64 + Operation int8 + }{} + for range lPlayToClientPacketEntityUpdateAttributesPropertiesElementModifiers { + var PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement struct { + Uuid string + Amount float64 + Operation int8 + } + PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Uuid, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Amount) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement.Operation) + if err != nil { + return + } + PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers = append(PlayToClientPacketEntityUpdateAttributesPropertiesElement.Modifiers, PlayToClientPacketEntityUpdateAttributesPropertiesElementModifiersElement) + } + ret.Properties = append(ret.Properties, PlayToClientPacketEntityUpdateAttributesPropertiesElement) + } + return +} + +var PlayToClientPacketEntityUpdateAttributesPropertiesInnerKeyReverseMap = map[string]int32{"generic.armor": 0, "generic.armor_toughness": 1, "player.entity_interaction_range": 10, "generic.fall_damage_multiplier": 11, "generic.flying_speed": 12, "generic.follow_range": 13, "generic.gravity": 14, "generic.jump_strength": 15, "generic.knockback_resistance": 16, "generic.luck": 17, "generic.max_absorption": 18, "generic.max_health": 19, "generic.attack_damage": 2, "generic.movement_speed": 20, "generic.safe_fall_distance": 21, "generic.scale": 22, "zombie.spawn_reinforcements": 23, "generic.step_height": 24, "submerged_mining_speed": 25, "sweeping_damage_ratio": 26, "tempt_range": 27, "water_movement_efficiency": 28, "waypoint_transmit_range": 29, "generic.attack_knockback": 3, "waypoint_receive_range": 30, "generic.attack_speed": 4, "player.block_break_speed": 5, "player.block_interaction_range": 6, "burning_time": 7, "camera_distance": 8, "explosion_knockback_resistance": 9} + +func (ret *PlayToClientPacketEntityUpdateAttributes) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Properties))) + if err != nil { + return + } + for iPlayToClientPacketEntityUpdateAttributesProperties := range len(ret.Properties) { + var vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey int32 + vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey, err = proto_base.ErroringIndex(PlayToClientPacketEntityUpdateAttributesPropertiesInnerKeyReverseMap, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Key) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketEntityUpdateAttributesPropertiesInnerKey) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Value) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers))) + if err != nil { + return + } + for iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers := range len(ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers) { + err = proto_base.EncodeString(w, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Uuid) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Amount) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Properties[iPlayToClientPacketEntityUpdateAttributesProperties].Modifiers[iPlayToClientPacketEntityUpdateAttributesPropertiesInnerModifiers].Operation) + if err != nil { + return + } + } + } + return +} + +type PlayToClientPacketEntityVelocity struct { + EntityId int32 + VelocityX int16 + VelocityY int16 + VelocityZ int16 +} + +func (ret *PlayToClientPacketEntityVelocity) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.VelocityX) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.VelocityY) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.VelocityZ) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketEntityVelocity) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.VelocityX) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.VelocityY) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.VelocityZ) + if err != nil { + return + } + return +} + +type PlayToClientPacketExperience struct { + ExperienceBar float32 + Level int32 + TotalExperience int32 +} + +func (ret *PlayToClientPacketExperience) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.ExperienceBar) + if err != nil { + return + } + ret.Level, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.TotalExperience, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketExperience) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.ExperienceBar) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Level) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.TotalExperience) + if err != nil { + return + } + return +} + +type PlayToClientPacketExplosion struct { + X float64 + Y float64 + Z float64 + PlayerKnockback *Vec3f + ExplosionParticle Particle + Sound ItemSoundHolder +} + +func (ret *PlayToClientPacketExplosion) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + var PlayToClientPacketExplosionPlayerKnockbackPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketExplosionPlayerKnockbackPresent) + if err != nil { + return + } + if PlayToClientPacketExplosionPlayerKnockbackPresent { + var PlayToClientPacketExplosionPlayerKnockbackPresentValue Vec3f + err = PlayToClientPacketExplosionPlayerKnockbackPresentValue.Decode(r) + if err != nil { + return + } + ret.PlayerKnockback = &PlayToClientPacketExplosionPlayerKnockbackPresentValue + } + err = ret.ExplosionParticle.Decode(r) + if err != nil { + return + } + err = ret.Sound.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketExplosion) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PlayerKnockback != nil) + if err != nil { + return + } + if ret.PlayerKnockback != nil { + err = (*ret.PlayerKnockback).Encode(w) + if err != nil { + return + } + } + err = ret.ExplosionParticle.Encode(w) + if err != nil { + return + } + err = ret.Sound.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketFacePlayer struct { + FeetEyes int32 + X float64 + Y float64 + Z float64 + IsEntity bool + EntityId any + EntityFeetEyes any +} + +func (ret *PlayToClientPacketFacePlayer) Decode(r io.Reader) (err error) { + ret.FeetEyes, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IsEntity) + if err != nil { + return + } + switch ret.IsEntity { + case true: + var PlayToClientPacketFacePlayerEntityIdTrueTmp int32 + PlayToClientPacketFacePlayerEntityIdTrueTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EntityId = PlayToClientPacketFacePlayerEntityIdTrueTmp + default: + var PlayToClientPacketFacePlayerEntityIdTmp struct { + } + ret.EntityId = PlayToClientPacketFacePlayerEntityIdTmp + } + switch ret.IsEntity { + case true: + var PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp int32 + PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTrueTmp + default: + var PlayToClientPacketFacePlayerEntityFeetEyesTmp struct { + } + ret.EntityFeetEyes = PlayToClientPacketFacePlayerEntityFeetEyesTmp + } + return +} +func (ret *PlayToClientPacketFacePlayer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.FeetEyes) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IsEntity) + if err != nil { + return + } + switch ret.IsEntity { + case true: + PlayToClientPacketFacePlayerEntityId, ok := ret.EntityId.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketFacePlayerEntityId) + if err != nil { + return + } + default: + _, ok := ret.EntityId.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.IsEntity { + case true: + PlayToClientPacketFacePlayerEntityFeetEyes, ok := ret.EntityFeetEyes.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketFacePlayerEntityFeetEyes) + if err != nil { + return + } + default: + _, ok := ret.EntityFeetEyes.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + return +} + +type PlayToClientPacketGameStateChange struct { + Reason string + GameMode float32 +} + +var PlayToClientPacketGameStateChangeReasonMap = map[uint8]string{0: "no_respawn_block_available", 1: "start_raining", 10: "guardian_elder_effect", 11: "immediate_respawn", 12: "limited_crafting", 13: "level_chunks_load_start", 2: "stop_raining", 3: "change_game_mode", 4: "win_game", 5: "demo_event", 6: "play_arrow_hit_sound", 7: "rain_level_change", 8: "thunder_level_change", 9: "puffer_fish_sting"} + +func (ret *PlayToClientPacketGameStateChange) Decode(r io.Reader) (err error) { + var PlayToClientPacketGameStateChangeReasonKey uint8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketGameStateChangeReasonKey) + if err != nil { + return + } + ret.Reason, err = proto_base.ErroringIndex(PlayToClientPacketGameStateChangeReasonMap, PlayToClientPacketGameStateChangeReasonKey) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.GameMode) + if err != nil { + return + } + return +} + +var PlayToClientPacketGameStateChangeReasonReverseMap = map[string]uint8{"no_respawn_block_available": 0, "start_raining": 1, "guardian_elder_effect": 10, "immediate_respawn": 11, "limited_crafting": 12, "level_chunks_load_start": 13, "stop_raining": 2, "change_game_mode": 3, "win_game": 4, "demo_event": 5, "play_arrow_hit_sound": 6, "rain_level_change": 7, "thunder_level_change": 8, "puffer_fish_sting": 9} + +func (ret *PlayToClientPacketGameStateChange) Encode(w io.Writer) (err error) { + var vPlayToClientPacketGameStateChangeReason uint8 + vPlayToClientPacketGameStateChangeReason, err = proto_base.ErroringIndex(PlayToClientPacketGameStateChangeReasonReverseMap, ret.Reason) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, vPlayToClientPacketGameStateChangeReason) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.GameMode) + if err != nil { + return + } + return +} + +type PlayToClientPacketHeldItemSlot struct { + Slot int32 +} + +func (ret *PlayToClientPacketHeldItemSlot) Decode(r io.Reader) (err error) { + ret.Slot, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketHeldItemSlot) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Slot) + if err != nil { + return + } + return +} + +type PlayToClientPacketHideMessage struct { + Id int32 + Signature any +} + +func (ret *PlayToClientPacketHideMessage) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + switch ret.Id { + case 0: + var PlayToClientPacketHideMessageSignature0Tmp [256]byte + _, err = r.Read(PlayToClientPacketHideMessageSignature0Tmp[:]) + if err != nil { + return + } + ret.Signature = PlayToClientPacketHideMessageSignature0Tmp + default: + var PlayToClientPacketHideMessageSignatureTmp struct { + } + ret.Signature = PlayToClientPacketHideMessageSignatureTmp + } + return +} +func (ret *PlayToClientPacketHideMessage) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Id) + if err != nil { + return + } + switch ret.Id { + case 0: + PlayToClientPacketHideMessageSignature, ok := ret.Signature.([256]byte) + if !ok { + err = proto_base.BadTypeError + return + } + arr := PlayToClientPacketHideMessageSignature + _, err = w.Write(arr[:]) + if err != nil { + return + } + default: + _, ok := ret.Signature.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + return +} + +type PlayToClientPacketHurtAnimation struct { + EntityId int32 + Yaw float32 +} + +func (ret *PlayToClientPacketHurtAnimation) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketHurtAnimation) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + return +} + +type PlayToClientPacketInitializeWorldBorder struct { + X float64 + Z float64 + OldDiameter float64 + NewDiameter float64 + Speed int32 + PortalTeleportBoundary int32 + WarningBlocks int32 + WarningTime int32 +} + +func (ret *PlayToClientPacketInitializeWorldBorder) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OldDiameter) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.NewDiameter) + if err != nil { + return + } + ret.Speed, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.PortalTeleportBoundary, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.WarningBlocks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.WarningTime, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketInitializeWorldBorder) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OldDiameter) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.NewDiameter) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Speed) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.PortalTeleportBoundary) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.WarningBlocks) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.WarningTime) + if err != nil { + return + } + return +} + +type PlayToClientPacketKeepAlive struct { + KeepAliveId int64 +} + +func (ret *PlayToClientPacketKeepAlive) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketKeepAlive) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.KeepAliveId) + if err != nil { + return + } + return +} + +type PlayToClientPacketKickDisconnect struct { + Reason nbt.Anon +} + +func (ret *PlayToClientPacketKickDisconnect) Decode(r io.Reader) (err error) { + err = ret.Reason.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketKickDisconnect) Encode(w io.Writer) (err error) { + err = ret.Reason.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketLogin struct { + EntityId int32 + IsHardcore bool + WorldNames []string + MaxPlayers int32 + ViewDistance int32 + SimulationDistance int32 + ReducedDebugInfo bool + EnableRespawnScreen bool + DoLimitedCrafting bool + WorldState PlayToClientSpawnInfo + EnforcesSecureChat bool +} + +func (ret *PlayToClientPacketLogin) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.EntityId) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IsHardcore) + if err != nil { + return + } + var lPlayToClientPacketLoginWorldNames int32 + lPlayToClientPacketLoginWorldNames, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.WorldNames = []string{} + for range lPlayToClientPacketLoginWorldNames { + var PlayToClientPacketLoginWorldNamesElement string + PlayToClientPacketLoginWorldNamesElement, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.WorldNames = append(ret.WorldNames, PlayToClientPacketLoginWorldNamesElement) + } + ret.MaxPlayers, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ViewDistance, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SimulationDistance, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ReducedDebugInfo) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableRespawnScreen) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.DoLimitedCrafting) + if err != nil { + return + } + err = ret.WorldState.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnforcesSecureChat) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketLogin) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IsHardcore) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.WorldNames))) + if err != nil { + return + } + for iPlayToClientPacketLoginWorldNames := range len(ret.WorldNames) { + err = proto_base.EncodeString(w, ret.WorldNames[iPlayToClientPacketLoginWorldNames]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, ret.MaxPlayers) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.SimulationDistance) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ReducedDebugInfo) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableRespawnScreen) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.DoLimitedCrafting) + if err != nil { + return + } + err = ret.WorldState.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnforcesSecureChat) + if err != nil { + return + } + return +} + +type PlayToClientPacketMap struct { + ItemDamage int32 + Scale int8 + Locked bool + Icons *[]struct { + Type int32 + X int8 + Z int8 + Direction uint8 + DisplayName *nbt.Anon + } + Columns uint8 + Rows any + X any + Y any + Data any +} + +func (ret *PlayToClientPacketMap) Decode(r io.Reader) (err error) { + ret.ItemDamage, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Scale) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Locked) + if err != nil { + return + } + var PlayToClientPacketMapIconsPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsPresent) + if err != nil { + return + } + if PlayToClientPacketMapIconsPresent { + var PlayToClientPacketMapIconsPresentValue []struct { + Type int32 + X int8 + Z int8 + Direction uint8 + DisplayName *nbt.Anon + } + var lPlayToClientPacketMapIcons int32 + lPlayToClientPacketMapIcons, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketMapIconsPresentValue = []struct { + Type int32 + X int8 + Z int8 + Direction uint8 + DisplayName *nbt.Anon + }{} + for range lPlayToClientPacketMapIcons { + var PlayToClientPacketMapIconsElement struct { + Type int32 + X int8 + Z int8 + Direction uint8 + DisplayName *nbt.Anon + } + PlayToClientPacketMapIconsElement.Type, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElement.Direction) + if err != nil { + return + } + var PlayToClientPacketMapIconsElementDisplayNamePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapIconsElementDisplayNamePresent) + if err != nil { + return + } + if PlayToClientPacketMapIconsElementDisplayNamePresent { + var PlayToClientPacketMapIconsElementDisplayNamePresentValue nbt.Anon + err = PlayToClientPacketMapIconsElementDisplayNamePresentValue.Decode(r) + if err != nil { + return + } + PlayToClientPacketMapIconsElement.DisplayName = &PlayToClientPacketMapIconsElementDisplayNamePresentValue + } + PlayToClientPacketMapIconsPresentValue = append(PlayToClientPacketMapIconsPresentValue, PlayToClientPacketMapIconsElement) + } + ret.Icons = &PlayToClientPacketMapIconsPresentValue + } + err = binary.Read(r, binary.BigEndian, &ret.Columns) + if err != nil { + return + } + switch ret.Columns { + case 0: + var PlayToClientPacketMapRows0Tmp struct { + } + ret.Rows = PlayToClientPacketMapRows0Tmp + default: + var PlayToClientPacketMapRowsTmp uint8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapRowsTmp) + if err != nil { + return + } + ret.Rows = PlayToClientPacketMapRowsTmp + } + switch ret.Columns { + case 0: + var PlayToClientPacketMapX0Tmp struct { + } + ret.X = PlayToClientPacketMapX0Tmp + default: + var PlayToClientPacketMapXTmp uint8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapXTmp) + if err != nil { + return + } + ret.X = PlayToClientPacketMapXTmp + } + switch ret.Columns { + case 0: + var PlayToClientPacketMapY0Tmp struct { + } + ret.Y = PlayToClientPacketMapY0Tmp + default: + var PlayToClientPacketMapYTmp uint8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapYTmp) + if err != nil { + return + } + ret.Y = PlayToClientPacketMapYTmp + } + switch ret.Columns { + case 0: + var PlayToClientPacketMapData0Tmp struct { + } + ret.Data = PlayToClientPacketMapData0Tmp + default: + var PlayToClientPacketMapDataTmp []byte + var lPlayToClientPacketMapData int32 + lPlayToClientPacketMapData, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketMapDataTmp, err = io.ReadAll(io.LimitReader(r, int64(lPlayToClientPacketMapData))) + if err != nil { + return + } + ret.Data = PlayToClientPacketMapDataTmp + } + return +} +func (ret *PlayToClientPacketMap) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.ItemDamage) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Scale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Locked) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Icons != nil) + if err != nil { + return + } + if ret.Icons != nil { + err = proto_base.EncodeVarInt(w, int32(len(*ret.Icons))) + if err != nil { + return + } + for iPlayToClientPacketMapIcons := range len(*ret.Icons) { + err = proto_base.EncodeVarInt(w, (*ret.Icons)[iPlayToClientPacketMapIcons].Type) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].Direction) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, (*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName != nil) + if err != nil { + return + } + if (*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName != nil { + err = (*(*ret.Icons)[iPlayToClientPacketMapIcons].DisplayName).Encode(w) + if err != nil { + return + } + } + } + } + err = binary.Write(w, binary.BigEndian, ret.Columns) + if err != nil { + return + } + switch ret.Columns { + case 0: + _, ok := ret.Rows.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + default: + _, ok := ret.Rows.(uint8) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, ret.Rows.(uint8)) + if err != nil { + return + } + } + switch ret.Columns { + case 0: + _, ok := ret.X.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + default: + _, ok := ret.X.(uint8) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, ret.X.(uint8)) + if err != nil { + return + } + } + switch ret.Columns { + case 0: + _, ok := ret.Y.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + default: + _, ok := ret.Y.(uint8) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, ret.Y.(uint8)) + if err != nil { + return + } + } + switch ret.Columns { + case 0: + _, ok := ret.Data.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + default: + _, ok := ret.Data.([]byte) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Data.([]byte)))) + if err != nil { + return + } + _, err = w.Write(ret.Data.([]byte)) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketMapChunk struct { + X int32 + Z int32 + Heightmaps []struct { + Type string + Data []int64 + } + ChunkData ByteArray + BlockEntities []ChunkBlockEntity + SkyLightMask []int64 + BlockLightMask []int64 + EmptySkyLightMask []int64 + EmptyBlockLightMask []int64 + SkyLight [][]uint8 + BlockLight [][]uint8 +} + +var PlayToClientPacketMapChunkHeightmapsElementTypeMap = map[int32]string{0: "world_surface_wg", 1: "world_surface", 2: "ocean_floor_wg", 3: "ocean_floor", 4: "motion_blocking", 5: "motion_blocking_no_leaves"} + +func (ret *PlayToClientPacketMapChunk) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + var lPlayToClientPacketMapChunkHeightmaps int32 + lPlayToClientPacketMapChunkHeightmaps, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Heightmaps = []struct { + Type string + Data []int64 + }{} + for range lPlayToClientPacketMapChunkHeightmaps { + var PlayToClientPacketMapChunkHeightmapsElement struct { + Type string + Data []int64 + } + var PlayToClientPacketMapChunkHeightmapsElementTypeKey int32 + PlayToClientPacketMapChunkHeightmapsElementTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketMapChunkHeightmapsElement.Type, err = proto_base.ErroringIndex(PlayToClientPacketMapChunkHeightmapsElementTypeMap, PlayToClientPacketMapChunkHeightmapsElementTypeKey) + if err != nil { + return + } + var lPlayToClientPacketMapChunkHeightmapsElementData int32 + lPlayToClientPacketMapChunkHeightmapsElementData, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketMapChunkHeightmapsElement.Data = []int64{} + for range lPlayToClientPacketMapChunkHeightmapsElementData { + var PlayToClientPacketMapChunkHeightmapsElementDataElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkHeightmapsElementDataElement) + if err != nil { + return + } + PlayToClientPacketMapChunkHeightmapsElement.Data = append(PlayToClientPacketMapChunkHeightmapsElement.Data, PlayToClientPacketMapChunkHeightmapsElementDataElement) + } + ret.Heightmaps = append(ret.Heightmaps, PlayToClientPacketMapChunkHeightmapsElement) + } + err = ret.ChunkData.Decode(r) + if err != nil { + return + } + var lPlayToClientPacketMapChunkBlockEntities int32 + lPlayToClientPacketMapChunkBlockEntities, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.BlockEntities = []ChunkBlockEntity{} + for range lPlayToClientPacketMapChunkBlockEntities { + var PlayToClientPacketMapChunkBlockEntitiesElement ChunkBlockEntity + err = PlayToClientPacketMapChunkBlockEntitiesElement.Decode(r) + if err != nil { + return + } + ret.BlockEntities = append(ret.BlockEntities, PlayToClientPacketMapChunkBlockEntitiesElement) + } + var lPlayToClientPacketMapChunkSkyLightMask int32 + lPlayToClientPacketMapChunkSkyLightMask, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SkyLightMask = []int64{} + for range lPlayToClientPacketMapChunkSkyLightMask { + var PlayToClientPacketMapChunkSkyLightMaskElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkSkyLightMaskElement) + if err != nil { + return + } + ret.SkyLightMask = append(ret.SkyLightMask, PlayToClientPacketMapChunkSkyLightMaskElement) + } + var lPlayToClientPacketMapChunkBlockLightMask int32 + lPlayToClientPacketMapChunkBlockLightMask, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.BlockLightMask = []int64{} + for range lPlayToClientPacketMapChunkBlockLightMask { + var PlayToClientPacketMapChunkBlockLightMaskElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBlockLightMaskElement) + if err != nil { + return + } + ret.BlockLightMask = append(ret.BlockLightMask, PlayToClientPacketMapChunkBlockLightMaskElement) + } + var lPlayToClientPacketMapChunkEmptySkyLightMask int32 + lPlayToClientPacketMapChunkEmptySkyLightMask, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EmptySkyLightMask = []int64{} + for range lPlayToClientPacketMapChunkEmptySkyLightMask { + var PlayToClientPacketMapChunkEmptySkyLightMaskElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkEmptySkyLightMaskElement) + if err != nil { + return + } + ret.EmptySkyLightMask = append(ret.EmptySkyLightMask, PlayToClientPacketMapChunkEmptySkyLightMaskElement) + } + var lPlayToClientPacketMapChunkEmptyBlockLightMask int32 + lPlayToClientPacketMapChunkEmptyBlockLightMask, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EmptyBlockLightMask = []int64{} + for range lPlayToClientPacketMapChunkEmptyBlockLightMask { + var PlayToClientPacketMapChunkEmptyBlockLightMaskElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkEmptyBlockLightMaskElement) + if err != nil { + return + } + ret.EmptyBlockLightMask = append(ret.EmptyBlockLightMask, PlayToClientPacketMapChunkEmptyBlockLightMaskElement) + } + var lPlayToClientPacketMapChunkSkyLight int32 + lPlayToClientPacketMapChunkSkyLight, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SkyLight = [][]uint8{} + for range lPlayToClientPacketMapChunkSkyLight { + var PlayToClientPacketMapChunkSkyLightElement []uint8 + var lPlayToClientPacketMapChunkSkyLightElement int32 + lPlayToClientPacketMapChunkSkyLightElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketMapChunkSkyLightElement = []uint8{} + for range lPlayToClientPacketMapChunkSkyLightElement { + var PlayToClientPacketMapChunkSkyLightElementElement uint8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkSkyLightElementElement) + if err != nil { + return + } + PlayToClientPacketMapChunkSkyLightElement = append(PlayToClientPacketMapChunkSkyLightElement, PlayToClientPacketMapChunkSkyLightElementElement) + } + ret.SkyLight = append(ret.SkyLight, PlayToClientPacketMapChunkSkyLightElement) + } + var lPlayToClientPacketMapChunkBlockLight int32 + lPlayToClientPacketMapChunkBlockLight, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.BlockLight = [][]uint8{} + for range lPlayToClientPacketMapChunkBlockLight { + var PlayToClientPacketMapChunkBlockLightElement []uint8 + var lPlayToClientPacketMapChunkBlockLightElement int32 + lPlayToClientPacketMapChunkBlockLightElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketMapChunkBlockLightElement = []uint8{} + for range lPlayToClientPacketMapChunkBlockLightElement { + var PlayToClientPacketMapChunkBlockLightElementElement uint8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMapChunkBlockLightElementElement) + if err != nil { + return + } + PlayToClientPacketMapChunkBlockLightElement = append(PlayToClientPacketMapChunkBlockLightElement, PlayToClientPacketMapChunkBlockLightElementElement) + } + ret.BlockLight = append(ret.BlockLight, PlayToClientPacketMapChunkBlockLightElement) + } + return +} + +var PlayToClientPacketMapChunkHeightmapsInnerTypeReverseMap = map[string]int32{"world_surface_wg": 0, "world_surface": 1, "ocean_floor_wg": 2, "ocean_floor": 3, "motion_blocking": 4, "motion_blocking_no_leaves": 5} + +func (ret *PlayToClientPacketMapChunk) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Heightmaps))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkHeightmaps := range len(ret.Heightmaps) { + var vPlayToClientPacketMapChunkHeightmapsInnerType int32 + vPlayToClientPacketMapChunkHeightmapsInnerType, err = proto_base.ErroringIndex(PlayToClientPacketMapChunkHeightmapsInnerTypeReverseMap, ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Type) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketMapChunkHeightmapsInnerType) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Data))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkHeightmapsInnerData := range len(ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Data) { + err = binary.Write(w, binary.BigEndian, ret.Heightmaps[iPlayToClientPacketMapChunkHeightmaps].Data[iPlayToClientPacketMapChunkHeightmapsInnerData]) + if err != nil { + return + } + } + } + err = ret.ChunkData.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.BlockEntities))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkBlockEntities := range len(ret.BlockEntities) { + err = ret.BlockEntities[iPlayToClientPacketMapChunkBlockEntities].Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLightMask))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkSkyLightMask := range len(ret.SkyLightMask) { + err = binary.Write(w, binary.BigEndian, ret.SkyLightMask[iPlayToClientPacketMapChunkSkyLightMask]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLightMask))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkBlockLightMask := range len(ret.BlockLightMask) { + err = binary.Write(w, binary.BigEndian, ret.BlockLightMask[iPlayToClientPacketMapChunkBlockLightMask]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.EmptySkyLightMask))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkEmptySkyLightMask := range len(ret.EmptySkyLightMask) { + err = binary.Write(w, binary.BigEndian, ret.EmptySkyLightMask[iPlayToClientPacketMapChunkEmptySkyLightMask]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.EmptyBlockLightMask))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkEmptyBlockLightMask := range len(ret.EmptyBlockLightMask) { + err = binary.Write(w, binary.BigEndian, ret.EmptyBlockLightMask[iPlayToClientPacketMapChunkEmptyBlockLightMask]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkSkyLight := range len(ret.SkyLight) { + err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight[iPlayToClientPacketMapChunkSkyLight]))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkSkyLightInner := range len(ret.SkyLight[iPlayToClientPacketMapChunkSkyLight]) { + err = binary.Write(w, binary.BigEndian, ret.SkyLight[iPlayToClientPacketMapChunkSkyLight][iPlayToClientPacketMapChunkSkyLightInner]) + if err != nil { + return + } + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkBlockLight := range len(ret.BlockLight) { + err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight[iPlayToClientPacketMapChunkBlockLight]))) + if err != nil { + return + } + for iPlayToClientPacketMapChunkBlockLightInner := range len(ret.BlockLight[iPlayToClientPacketMapChunkBlockLight]) { + err = binary.Write(w, binary.BigEndian, ret.BlockLight[iPlayToClientPacketMapChunkBlockLight][iPlayToClientPacketMapChunkBlockLightInner]) + if err != nil { + return + } + } + } + return +} + +type PlayToClientPacketMoveMinecart struct { + EntityId int32 + Steps []struct { + Position Vec3f + Movement Vec3f + Yaw float32 + Pitch float32 + Weight float32 + } +} + +func (ret *PlayToClientPacketMoveMinecart) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lPlayToClientPacketMoveMinecartSteps int32 + lPlayToClientPacketMoveMinecartSteps, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Steps = []struct { + Position Vec3f + Movement Vec3f + Yaw float32 + Pitch float32 + Weight float32 + }{} + for range lPlayToClientPacketMoveMinecartSteps { + var PlayToClientPacketMoveMinecartStepsElement struct { + Position Vec3f + Movement Vec3f + Yaw float32 + Pitch float32 + Weight float32 + } + err = PlayToClientPacketMoveMinecartStepsElement.Position.Decode(r) + if err != nil { + return + } + err = PlayToClientPacketMoveMinecartStepsElement.Movement.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMoveMinecartStepsElement.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMoveMinecartStepsElement.Pitch) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketMoveMinecartStepsElement.Weight) + if err != nil { + return + } + ret.Steps = append(ret.Steps, PlayToClientPacketMoveMinecartStepsElement) + } + return +} +func (ret *PlayToClientPacketMoveMinecart) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Steps))) + if err != nil { + return + } + for iPlayToClientPacketMoveMinecartSteps := range len(ret.Steps) { + err = ret.Steps[iPlayToClientPacketMoveMinecartSteps].Position.Encode(w) + if err != nil { + return + } + err = ret.Steps[iPlayToClientPacketMoveMinecartSteps].Movement.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Steps[iPlayToClientPacketMoveMinecartSteps].Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Steps[iPlayToClientPacketMoveMinecartSteps].Pitch) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Steps[iPlayToClientPacketMoveMinecartSteps].Weight) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketMultiBlockChange struct { + ChunkCoordinates uint64 + Records []int32 +} + +func (ret *PlayToClientPacketMultiBlockChange) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.ChunkCoordinates) + if err != nil { + return + } + var lPlayToClientPacketMultiBlockChangeRecords int32 + lPlayToClientPacketMultiBlockChangeRecords, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Records = []int32{} + for range lPlayToClientPacketMultiBlockChangeRecords { + var PlayToClientPacketMultiBlockChangeRecordsElement int32 + PlayToClientPacketMultiBlockChangeRecordsElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Records = append(ret.Records, PlayToClientPacketMultiBlockChangeRecordsElement) + } + return +} +func (ret *PlayToClientPacketMultiBlockChange) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.ChunkCoordinates) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Records))) + if err != nil { + return + } + for iPlayToClientPacketMultiBlockChangeRecords := range len(ret.Records) { + err = proto_base.EncodeVarInt(w, ret.Records[iPlayToClientPacketMultiBlockChangeRecords]) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketNbtQueryResponse struct { + TransactionId int32 + Nbt nbt.Anon +} + +func (ret *PlayToClientPacketNbtQueryResponse) Decode(r io.Reader) (err error) { + ret.TransactionId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.Nbt.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketNbtQueryResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.TransactionId) + if err != nil { + return + } + err = ret.Nbt.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketOpenBook struct { + Hand int32 +} + +func (ret *PlayToClientPacketOpenBook) Decode(r io.Reader) (err error) { + ret.Hand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketOpenBook) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Hand) + if err != nil { + return + } + return +} + +type PlayToClientPacketOpenHorseWindow struct { + WindowId ContainerID + NbSlots int32 + EntityId int32 +} + +func (ret *PlayToClientPacketOpenHorseWindow) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + ret.NbSlots, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EntityId) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketOpenHorseWindow) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.NbSlots) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EntityId) + if err != nil { + return + } + return +} + +type PlayToClientPacketOpenSignEntity struct { + Location Position + IsFrontText bool +} + +func (ret *PlayToClientPacketOpenSignEntity) Decode(r io.Reader) (err error) { + err = ret.Location.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IsFrontText) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketOpenSignEntity) Encode(w io.Writer) (err error) { + err = ret.Location.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IsFrontText) + if err != nil { + return + } + return +} + +type PlayToClientPacketOpenWindow struct { + WindowId int32 + InventoryType int32 + WindowTitle nbt.Anon +} + +func (ret *PlayToClientPacketOpenWindow) Decode(r io.Reader) (err error) { + ret.WindowId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.InventoryType, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.WindowTitle.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketOpenWindow) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.WindowId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.InventoryType) + if err != nil { + return + } + err = ret.WindowTitle.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketPing struct { + Id int32 +} + +func (ret *PlayToClientPacketPing) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Id) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketPing) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Id) + if err != nil { + return + } + return +} + +type PlayToClientPacketPingResponse struct { + Id int64 +} + +func (ret *PlayToClientPacketPingResponse) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Id) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketPingResponse) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Id) + if err != nil { + return + } + return +} + +type PlayToClientPacketPlayerChat struct { + GlobalIndex int32 + SenderUuid uuid.UUID + Index int32 + Signature *[256]byte + PlainMessage string + Timestamp int64 + Salt int64 + PreviousMessages PreviousMessages + UnsignedChatContent *nbt.Anon + FilterType int32 + FilterTypeMask any + Type PlayToClientChatTypesHolder + NetworkName nbt.Anon + NetworkTargetName *nbt.Anon +} + +func (ret *PlayToClientPacketPlayerChat) Decode(r io.Reader) (err error) { + ret.GlobalIndex, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + _, err = io.ReadFull(r, ret.SenderUuid[:]) + if err != nil { + return + } + ret.Index, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var PlayToClientPacketPlayerChatSignaturePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatSignaturePresent) + if err != nil { + return + } + if PlayToClientPacketPlayerChatSignaturePresent { + var PlayToClientPacketPlayerChatSignaturePresentValue [256]byte + _, err = r.Read(PlayToClientPacketPlayerChatSignaturePresentValue[:]) + if err != nil { + return + } + ret.Signature = &PlayToClientPacketPlayerChatSignaturePresentValue + } + ret.PlainMessage, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Timestamp) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Salt) + if err != nil { + return + } + err = ret.PreviousMessages.Decode(r) + if err != nil { + return + } + var PlayToClientPacketPlayerChatUnsignedChatContentPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatUnsignedChatContentPresent) + if err != nil { + return + } + if PlayToClientPacketPlayerChatUnsignedChatContentPresent { + var PlayToClientPacketPlayerChatUnsignedChatContentPresentValue nbt.Anon + err = PlayToClientPacketPlayerChatUnsignedChatContentPresentValue.Decode(r) + if err != nil { + return + } + ret.UnsignedChatContent = &PlayToClientPacketPlayerChatUnsignedChatContentPresentValue + } + ret.FilterType, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + switch ret.FilterType { + case 2: + var PlayToClientPacketPlayerChatFilterTypeMask2Tmp []int64 + var lPlayToClientPacketPlayerChatFilterTypeMask int32 + lPlayToClientPacketPlayerChatFilterTypeMask, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketPlayerChatFilterTypeMask2Tmp = []int64{} + for range lPlayToClientPacketPlayerChatFilterTypeMask { + var PlayToClientPacketPlayerChatFilterTypeMaskElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatFilterTypeMaskElement) + if err != nil { + return + } + PlayToClientPacketPlayerChatFilterTypeMask2Tmp = append(PlayToClientPacketPlayerChatFilterTypeMask2Tmp, PlayToClientPacketPlayerChatFilterTypeMaskElement) + } + ret.FilterTypeMask = PlayToClientPacketPlayerChatFilterTypeMask2Tmp + default: + var PlayToClientPacketPlayerChatFilterTypeMaskTmp struct { + } + ret.FilterTypeMask = PlayToClientPacketPlayerChatFilterTypeMaskTmp + } + err = ret.Type.Decode(r) + if err != nil { + return + } + err = ret.NetworkName.Decode(r) + if err != nil { + return + } + var PlayToClientPacketPlayerChatNetworkTargetNamePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerChatNetworkTargetNamePresent) + if err != nil { + return + } + if PlayToClientPacketPlayerChatNetworkTargetNamePresent { + var PlayToClientPacketPlayerChatNetworkTargetNamePresentValue nbt.Anon + err = PlayToClientPacketPlayerChatNetworkTargetNamePresentValue.Decode(r) + if err != nil { + return + } + ret.NetworkTargetName = &PlayToClientPacketPlayerChatNetworkTargetNamePresentValue + } + return +} +func (ret *PlayToClientPacketPlayerChat) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.GlobalIndex) + if err != nil { + return + } + _, err = w.Write(ret.SenderUuid[:]) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Index) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Signature != nil) + if err != nil { + return + } + if ret.Signature != nil { + arr := *ret.Signature + _, err = w.Write(arr[:]) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.PlainMessage) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Timestamp) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Salt) + if err != nil { + return + } + err = ret.PreviousMessages.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.UnsignedChatContent != nil) + if err != nil { + return + } + if ret.UnsignedChatContent != nil { + err = (*ret.UnsignedChatContent).Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, ret.FilterType) + if err != nil { + return + } + switch ret.FilterType { + case 2: + PlayToClientPacketPlayerChatFilterTypeMask, ok := ret.FilterTypeMask.([]int64) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketPlayerChatFilterTypeMask))) + if err != nil { + return + } + for iPlayToClientPacketPlayerChatFilterTypeMask := range len(PlayToClientPacketPlayerChatFilterTypeMask) { + err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerChatFilterTypeMask[iPlayToClientPacketPlayerChatFilterTypeMask]) + if err != nil { + return + } + } + default: + _, ok := ret.FilterTypeMask.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + err = ret.Type.Encode(w) + if err != nil { + return + } + err = ret.NetworkName.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.NetworkTargetName != nil) + if err != nil { + return + } + if ret.NetworkTargetName != nil { + err = (*ret.NetworkTargetName).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketPlayerInfo struct { + Action uint8 + Data []struct { + Uuid uuid.UUID + Player any + ChatSession any + Gamemode any + Listed any + Latency any + DisplayName any + ListPriority any + ShowHat any + } +} + +func (ret *PlayToClientPacketPlayerInfo) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Action) + if err != nil { + return + } + var lPlayToClientPacketPlayerInfoData int32 + lPlayToClientPacketPlayerInfoData, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Data = []struct { + Uuid uuid.UUID + Player any + ChatSession any + Gamemode any + Listed any + Latency any + DisplayName any + ListPriority any + ShowHat any + }{} + for range lPlayToClientPacketPlayerInfoData { + var PlayToClientPacketPlayerInfoDataElement struct { + Uuid uuid.UUID + Player any + ChatSession any + Gamemode any + Listed any + Latency any + DisplayName any + ListPriority any + ShowHat any + } + _, err = io.ReadFull(r, PlayToClientPacketPlayerInfoDataElement.Uuid[:]) + if err != nil { + return + } + switch ret.Action&1 != 0 { + case true: + var PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp GameProfile + err = PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp.Decode(r) + if err != nil { + return + } + PlayToClientPacketPlayerInfoDataElement.Player = PlayToClientPacketPlayerInfoDataElementPlayerTrueTmp + default: + var PlayToClientPacketPlayerInfoDataElementPlayerTmp struct { + } + PlayToClientPacketPlayerInfoDataElement.Player = PlayToClientPacketPlayerInfoDataElementPlayerTmp + } + switch ret.Action&2 != 0 { + case true: + var PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp ChatSession + err = PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp.Decode(r) + if err != nil { + return + } + PlayToClientPacketPlayerInfoDataElement.ChatSession = PlayToClientPacketPlayerInfoDataElementChatSessionTrueTmp + default: + var PlayToClientPacketPlayerInfoDataElementChatSessionTmp struct { + } + PlayToClientPacketPlayerInfoDataElement.ChatSession = PlayToClientPacketPlayerInfoDataElementChatSessionTmp + } + switch ret.Action&4 != 0 { + case true: + var PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp int32 + PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketPlayerInfoDataElement.Gamemode = PlayToClientPacketPlayerInfoDataElementGamemodeTrueTmp + default: + var PlayToClientPacketPlayerInfoDataElementGamemodeTmp struct { + } + PlayToClientPacketPlayerInfoDataElement.Gamemode = PlayToClientPacketPlayerInfoDataElementGamemodeTmp + } + switch ret.Action&8 != 0 { + case true: + var PlayToClientPacketPlayerInfoDataElementListedTrueTmp int32 + PlayToClientPacketPlayerInfoDataElementListedTrueTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketPlayerInfoDataElement.Listed = PlayToClientPacketPlayerInfoDataElementListedTrueTmp + default: + var PlayToClientPacketPlayerInfoDataElementListedTmp struct { + } + PlayToClientPacketPlayerInfoDataElement.Listed = PlayToClientPacketPlayerInfoDataElementListedTmp + } + switch ret.Action&10 != 0 { + case true: + var PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp int32 + PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketPlayerInfoDataElement.Latency = PlayToClientPacketPlayerInfoDataElementLatencyTrueTmp + default: + var PlayToClientPacketPlayerInfoDataElementLatencyTmp struct { + } + PlayToClientPacketPlayerInfoDataElement.Latency = PlayToClientPacketPlayerInfoDataElementLatencyTmp + } + switch ret.Action&20 != 0 { + case true: + var PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp *nbt.Anon + var PlayToClientPacketPlayerInfoDataElementDisplayNamePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementDisplayNamePresent) + if err != nil { + return + } + if PlayToClientPacketPlayerInfoDataElementDisplayNamePresent { + var PlayToClientPacketPlayerInfoDataElementDisplayNamePresentValue nbt.Anon + err = PlayToClientPacketPlayerInfoDataElementDisplayNamePresentValue.Decode(r) + if err != nil { + return + } + PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp = &PlayToClientPacketPlayerInfoDataElementDisplayNamePresentValue + } + PlayToClientPacketPlayerInfoDataElement.DisplayName = PlayToClientPacketPlayerInfoDataElementDisplayNameTrueTmp + default: + var PlayToClientPacketPlayerInfoDataElementDisplayNameTmp struct { + } + PlayToClientPacketPlayerInfoDataElement.DisplayName = PlayToClientPacketPlayerInfoDataElementDisplayNameTmp + } + switch ret.Action&80 != 0 { + case true: + var PlayToClientPacketPlayerInfoDataElementListPriorityTrueTmp int32 + PlayToClientPacketPlayerInfoDataElementListPriorityTrueTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketPlayerInfoDataElement.ListPriority = PlayToClientPacketPlayerInfoDataElementListPriorityTrueTmp + default: + var PlayToClientPacketPlayerInfoDataElementListPriorityTmp struct { + } + PlayToClientPacketPlayerInfoDataElement.ListPriority = PlayToClientPacketPlayerInfoDataElementListPriorityTmp + } + switch ret.Action&40 != 0 { + case true: + var PlayToClientPacketPlayerInfoDataElementShowHatTrueTmp bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketPlayerInfoDataElementShowHatTrueTmp) + if err != nil { + return + } + PlayToClientPacketPlayerInfoDataElement.ShowHat = PlayToClientPacketPlayerInfoDataElementShowHatTrueTmp + default: + var PlayToClientPacketPlayerInfoDataElementShowHatTmp struct { + } + PlayToClientPacketPlayerInfoDataElement.ShowHat = PlayToClientPacketPlayerInfoDataElementShowHatTmp + } + ret.Data = append(ret.Data, PlayToClientPacketPlayerInfoDataElement) + } + return +} +func (ret *PlayToClientPacketPlayerInfo) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Action) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Data))) + if err != nil { + return + } + for iPlayToClientPacketPlayerInfoData := range len(ret.Data) { + _, err = w.Write(ret.Data[iPlayToClientPacketPlayerInfoData].Uuid[:]) + if err != nil { + return + } + switch ret.Action&1 != 0 { + case true: + PlayToClientPacketPlayerInfoDataInnerPlayer, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Player.(GameProfile) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketPlayerInfoDataInnerPlayer.Encode(w) + if err != nil { + return + } + default: + _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Player.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action&2 != 0 { + case true: + PlayToClientPacketPlayerInfoDataInnerChatSession, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(ChatSession) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketPlayerInfoDataInnerChatSession.Encode(w) + if err != nil { + return + } + default: + _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ChatSession.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action&4 != 0 { + case true: + PlayToClientPacketPlayerInfoDataInnerGamemode, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerGamemode) + if err != nil { + return + } + default: + _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Gamemode.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action&8 != 0 { + case true: + PlayToClientPacketPlayerInfoDataInnerListed, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerListed) + if err != nil { + return + } + default: + _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Listed.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action&10 != 0 { + case true: + PlayToClientPacketPlayerInfoDataInnerLatency, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerLatency) + if err != nil { + return + } + default: + _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].Latency.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action&20 != 0 { + case true: + PlayToClientPacketPlayerInfoDataInnerDisplayName, ok := ret.Data[iPlayToClientPacketPlayerInfoData].DisplayName.(*nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerDisplayName != nil) + if err != nil { + return + } + if PlayToClientPacketPlayerInfoDataInnerDisplayName != nil { + err = (*PlayToClientPacketPlayerInfoDataInnerDisplayName).Encode(w) + if err != nil { + return + } + } + default: + _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].DisplayName.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action&80 != 0 { + case true: + PlayToClientPacketPlayerInfoDataInnerListPriority, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ListPriority.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketPlayerInfoDataInnerListPriority) + if err != nil { + return + } + default: + _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ListPriority.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action&40 != 0 { + case true: + PlayToClientPacketPlayerInfoDataInnerShowHat, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ShowHat.(bool) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketPlayerInfoDataInnerShowHat) + if err != nil { + return + } + default: + _, ok := ret.Data[iPlayToClientPacketPlayerInfoData].ShowHat.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + } + return +} + +type PlayToClientPacketPlayerRemove struct { + Players []uuid.UUID +} + +func (ret *PlayToClientPacketPlayerRemove) Decode(r io.Reader) (err error) { + var lPlayToClientPacketPlayerRemovePlayers int32 + lPlayToClientPacketPlayerRemovePlayers, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Players = []uuid.UUID{} + for range lPlayToClientPacketPlayerRemovePlayers { + var PlayToClientPacketPlayerRemovePlayersElement uuid.UUID + _, err = io.ReadFull(r, PlayToClientPacketPlayerRemovePlayersElement[:]) + if err != nil { + return + } + ret.Players = append(ret.Players, PlayToClientPacketPlayerRemovePlayersElement) + } + return +} +func (ret *PlayToClientPacketPlayerRemove) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Players))) + if err != nil { + return + } + for iPlayToClientPacketPlayerRemovePlayers := range len(ret.Players) { + _, err = w.Write(ret.Players[iPlayToClientPacketPlayerRemovePlayers][:]) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketPlayerRotation struct { + Yaw float32 + Pitch float32 +} + +func (ret *PlayToClientPacketPlayerRotation) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketPlayerRotation) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + return +} + +type PlayToClientPacketPlayerlistHeader struct { + Header nbt.Anon + Footer nbt.Anon +} + +func (ret *PlayToClientPacketPlayerlistHeader) Decode(r io.Reader) (err error) { + err = ret.Header.Decode(r) + if err != nil { + return + } + err = ret.Footer.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketPlayerlistHeader) Encode(w io.Writer) (err error) { + err = ret.Header.Encode(w) + if err != nil { + return + } + err = ret.Footer.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketPosition struct { + TeleportId int32 + X float64 + Y float64 + Z float64 + Dx float64 + Dy float64 + Dz float64 + Yaw float32 + Pitch float32 + Flags PlayToClientPositionUpdateRelatives +} + +func (ret *PlayToClientPacketPosition) Decode(r io.Reader) (err error) { + ret.TeleportId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Dx) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Dy) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Dz) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = ret.Flags.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketPosition) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.TeleportId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Dx) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Dy) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Dz) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = ret.Flags.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketProfilelessChat struct { + Message nbt.Anon + Type PlayToClientChatTypesHolder + Name nbt.Anon + Target *nbt.Anon +} + +func (ret *PlayToClientPacketProfilelessChat) Decode(r io.Reader) (err error) { + err = ret.Message.Decode(r) + if err != nil { + return + } + err = ret.Type.Decode(r) + if err != nil { + return + } + err = ret.Name.Decode(r) + if err != nil { + return + } + var PlayToClientPacketProfilelessChatTargetPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketProfilelessChatTargetPresent) + if err != nil { + return + } + if PlayToClientPacketProfilelessChatTargetPresent { + var PlayToClientPacketProfilelessChatTargetPresentValue nbt.Anon + err = PlayToClientPacketProfilelessChatTargetPresentValue.Decode(r) + if err != nil { + return + } + ret.Target = &PlayToClientPacketProfilelessChatTargetPresentValue + } + return +} +func (ret *PlayToClientPacketProfilelessChat) Encode(w io.Writer) (err error) { + err = ret.Message.Encode(w) + if err != nil { + return + } + err = ret.Type.Encode(w) + if err != nil { + return + } + err = ret.Name.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Target != nil) + if err != nil { + return + } + if ret.Target != nil { + err = (*ret.Target).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketRecipeBookAdd struct { + Entries []struct { + Recipe struct { + DisplayId int32 + Display PlayToClientRecipeDisplay + Group Optvarint + Category string + CraftingRequirements *[]IDSet + } + Flags uint8 + } + Replace bool +} + +var PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryMap = map[int32]string{0: "crafting_building_blocks", 1: "crafting_redstone", 10: "stonecutter", 11: "smithing", 12: "campfire", 2: "crafting_equipment", 3: "crafting_misc", 4: "furnace_food", 5: "furnace_blocks", 6: "furnace_misc", 7: "blast_furnace_blocks", 8: "blast_furnace_misc", 9: "smoker_food"} + +func (ret *PlayToClientPacketRecipeBookAdd) Decode(r io.Reader) (err error) { + var lPlayToClientPacketRecipeBookAddEntries int32 + lPlayToClientPacketRecipeBookAddEntries, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Entries = []struct { + Recipe struct { + DisplayId int32 + Display PlayToClientRecipeDisplay + Group Optvarint + Category string + CraftingRequirements *[]IDSet + } + Flags uint8 + }{} + for range lPlayToClientPacketRecipeBookAddEntries { + var PlayToClientPacketRecipeBookAddEntriesElement struct { + Recipe struct { + DisplayId int32 + Display PlayToClientRecipeDisplay + Group Optvarint + Category string + CraftingRequirements *[]IDSet + } + Flags uint8 + } + PlayToClientPacketRecipeBookAddEntriesElement.Recipe.DisplayId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Display.Decode(r) + if err != nil { + return + } + err = PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Group.Decode(r) + if err != nil { + return + } + var PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey int32 + PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketRecipeBookAddEntriesElement.Recipe.Category, err = proto_base.ErroringIndex(PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryMap, PlayToClientPacketRecipeBookAddEntriesElementRecipeCategoryKey) + if err != nil { + return + } + var PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresent) + if err != nil { + return + } + if PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresent { + var PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue []IDSet + var lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements int32 + lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue = []IDSet{} + for range lPlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirements { + var PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement IDSet + err = PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement.Decode(r) + if err != nil { + return + } + PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue = append(PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue, PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsElement) + } + PlayToClientPacketRecipeBookAddEntriesElement.Recipe.CraftingRequirements = &PlayToClientPacketRecipeBookAddEntriesElementRecipeCraftingRequirementsPresentValue + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketRecipeBookAddEntriesElement.Flags) + if err != nil { + return + } + ret.Entries = append(ret.Entries, PlayToClientPacketRecipeBookAddEntriesElement) + } + err = binary.Read(r, binary.BigEndian, &ret.Replace) + if err != nil { + return + } + return +} + +var PlayToClientPacketRecipeBookAddEntriesInnerRecipeCategoryReverseMap = map[string]int32{"crafting_building_blocks": 0, "crafting_redstone": 1, "stonecutter": 10, "smithing": 11, "campfire": 12, "crafting_equipment": 2, "crafting_misc": 3, "furnace_food": 4, "furnace_blocks": 5, "furnace_misc": 6, "blast_furnace_blocks": 7, "blast_furnace_misc": 8, "smoker_food": 9} + +func (ret *PlayToClientPacketRecipeBookAdd) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Entries))) + if err != nil { + return + } + for iPlayToClientPacketRecipeBookAddEntries := range len(ret.Entries) { + err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.DisplayId) + if err != nil { + return + } + err = ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Display.Encode(w) + if err != nil { + return + } + err = ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Group.Encode(w) + if err != nil { + return + } + var vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory int32 + vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory, err = proto_base.ErroringIndex(PlayToClientPacketRecipeBookAddEntriesInnerRecipeCategoryReverseMap, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.Category) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketRecipeBookAddEntriesInnerRecipeCategory) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements != nil) + if err != nil { + return + } + if ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements != nil { + err = proto_base.EncodeVarInt(w, int32(len(*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements))) + if err != nil { + return + } + for iPlayToClientPacketRecipeBookAddEntriesInnerRecipeCraftingRequirements := range len(*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements) { + err = (*ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Recipe.CraftingRequirements)[iPlayToClientPacketRecipeBookAddEntriesInnerRecipeCraftingRequirements].Encode(w) + if err != nil { + return + } + } + } + err = binary.Write(w, binary.BigEndian, ret.Entries[iPlayToClientPacketRecipeBookAddEntries].Flags) + if err != nil { + return + } + } + err = binary.Write(w, binary.BigEndian, ret.Replace) + if err != nil { + return + } + return +} + +type PlayToClientPacketRecipeBookRemove struct { + RecipeIds []int32 +} + +func (ret *PlayToClientPacketRecipeBookRemove) Decode(r io.Reader) (err error) { + var lPlayToClientPacketRecipeBookRemoveRecipeIds int32 + lPlayToClientPacketRecipeBookRemoveRecipeIds, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.RecipeIds = []int32{} + for range lPlayToClientPacketRecipeBookRemoveRecipeIds { + var PlayToClientPacketRecipeBookRemoveRecipeIdsElement int32 + PlayToClientPacketRecipeBookRemoveRecipeIdsElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.RecipeIds = append(ret.RecipeIds, PlayToClientPacketRecipeBookRemoveRecipeIdsElement) + } + return +} +func (ret *PlayToClientPacketRecipeBookRemove) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.RecipeIds))) + if err != nil { + return + } + for iPlayToClientPacketRecipeBookRemoveRecipeIds := range len(ret.RecipeIds) { + err = proto_base.EncodeVarInt(w, ret.RecipeIds[iPlayToClientPacketRecipeBookRemoveRecipeIds]) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketRecipeBookSettings struct { + Crafting PlayToClientRecipeBookSetting + Furnace PlayToClientRecipeBookSetting + Blast PlayToClientRecipeBookSetting + Smoker PlayToClientRecipeBookSetting +} + +func (ret *PlayToClientPacketRecipeBookSettings) Decode(r io.Reader) (err error) { + err = ret.Crafting.Decode(r) + if err != nil { + return + } + err = ret.Furnace.Decode(r) + if err != nil { + return + } + err = ret.Blast.Decode(r) + if err != nil { + return + } + err = ret.Smoker.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketRecipeBookSettings) Encode(w io.Writer) (err error) { + err = ret.Crafting.Encode(w) + if err != nil { + return + } + err = ret.Furnace.Encode(w) + if err != nil { + return + } + err = ret.Blast.Encode(w) + if err != nil { + return + } + err = ret.Smoker.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketRelEntityMove struct { + EntityId int32 + DX int16 + DY int16 + DZ int16 + OnGround bool +} + +func (ret *PlayToClientPacketRelEntityMove) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.DX) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.DY) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.DZ) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OnGround) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketRelEntityMove) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.DX) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.DY) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.DZ) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OnGround) + if err != nil { + return + } + return +} + +type PlayToClientPacketRemoveEntityEffect struct { + EntityId int32 + EffectId int32 +} + +func (ret *PlayToClientPacketRemoveEntityEffect) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EffectId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketRemoveEntityEffect) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.EffectId) + if err != nil { + return + } + return +} + +type PlayToClientPacketResetScore struct { + EntityName string + ObjectiveName *string +} + +func (ret *PlayToClientPacketResetScore) Decode(r io.Reader) (err error) { + ret.EntityName, err = proto_base.DecodeString(r) + if err != nil { + return + } + var PlayToClientPacketResetScoreObjectiveNamePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketResetScoreObjectiveNamePresent) + if err != nil { + return + } + if PlayToClientPacketResetScoreObjectiveNamePresent { + var PlayToClientPacketResetScoreObjectiveNamePresentValue string + PlayToClientPacketResetScoreObjectiveNamePresentValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.ObjectiveName = &PlayToClientPacketResetScoreObjectiveNamePresentValue + } + return +} +func (ret *PlayToClientPacketResetScore) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.EntityName) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ObjectiveName != nil) + if err != nil { + return + } + if ret.ObjectiveName != nil { + err = proto_base.EncodeString(w, *ret.ObjectiveName) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketRespawn struct { + WorldState PlayToClientSpawnInfo + CopyMetadata uint8 +} + +func (ret *PlayToClientPacketRespawn) Decode(r io.Reader) (err error) { + err = ret.WorldState.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.CopyMetadata) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketRespawn) Encode(w io.Writer) (err error) { + err = ret.WorldState.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.CopyMetadata) + if err != nil { + return + } + return +} + +type PlayToClientPacketScoreboardDisplayObjective struct { + Position int32 + Name string +} + +func (ret *PlayToClientPacketScoreboardDisplayObjective) Decode(r io.Reader) (err error) { + ret.Position, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketScoreboardDisplayObjective) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Position) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Name) + if err != nil { + return + } + return +} + +type PlayToClientPacketScoreboardObjective struct { + Name string + Action int8 + DisplayText any + Type any + NumberFormat any + Styling any +} + +func (ret *PlayToClientPacketScoreboardObjective) Decode(r io.Reader) (err error) { + ret.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Action) + if err != nil { + return + } + switch ret.Action { + case 0: + var PlayToClientPacketScoreboardObjectiveDisplayText0Tmp nbt.Anon + err = PlayToClientPacketScoreboardObjectiveDisplayText0Tmp.Decode(r) + if err != nil { + return + } + ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText0Tmp + case 2: + var PlayToClientPacketScoreboardObjectiveDisplayText2Tmp nbt.Anon + err = PlayToClientPacketScoreboardObjectiveDisplayText2Tmp.Decode(r) + if err != nil { + return + } + ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayText2Tmp + default: + var PlayToClientPacketScoreboardObjectiveDisplayTextTmp struct { + } + ret.DisplayText = PlayToClientPacketScoreboardObjectiveDisplayTextTmp + } + switch ret.Action { + case 0: + var PlayToClientPacketScoreboardObjectiveType0Tmp int32 + PlayToClientPacketScoreboardObjectiveType0Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Type = PlayToClientPacketScoreboardObjectiveType0Tmp + case 2: + var PlayToClientPacketScoreboardObjectiveType2Tmp int32 + PlayToClientPacketScoreboardObjectiveType2Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Type = PlayToClientPacketScoreboardObjectiveType2Tmp + default: + var PlayToClientPacketScoreboardObjectiveTypeTmp struct { + } + ret.Type = PlayToClientPacketScoreboardObjectiveTypeTmp + } + switch ret.Action { + case 0: + var PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp *int32 + var PlayToClientPacketScoreboardObjectiveNumberFormatPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardObjectiveNumberFormatPresent) + if err != nil { + return + } + if PlayToClientPacketScoreboardObjectiveNumberFormatPresent { + var PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue int32 + PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp = &PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue + } + ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormat0Tmp + case 2: + var PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp *int32 + var PlayToClientPacketScoreboardObjectiveNumberFormatPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketScoreboardObjectiveNumberFormatPresent) + if err != nil { + return + } + if PlayToClientPacketScoreboardObjectiveNumberFormatPresent { + var PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue int32 + PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp = &PlayToClientPacketScoreboardObjectiveNumberFormatPresentValue + } + ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormat2Tmp + default: + var PlayToClientPacketScoreboardObjectiveNumberFormatTmp struct { + } + ret.NumberFormat = PlayToClientPacketScoreboardObjectiveNumberFormatTmp + } + switch ret.Action { + case 0: + var PlayToClientPacketScoreboardObjectiveStyling0Tmp any + switch ret.NumberFormat { + case 1: + var PlayToClientPacketScoreboardObjectiveStyling1Tmp nbt.Anon + err = PlayToClientPacketScoreboardObjectiveStyling1Tmp.Decode(r) + if err != nil { + return + } + PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStyling1Tmp + case 2: + var PlayToClientPacketScoreboardObjectiveStyling2Tmp nbt.Anon + err = PlayToClientPacketScoreboardObjectiveStyling2Tmp.Decode(r) + if err != nil { + return + } + PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStyling2Tmp + default: + var PlayToClientPacketScoreboardObjectiveStylingTmp struct { + } + PlayToClientPacketScoreboardObjectiveStyling0Tmp = PlayToClientPacketScoreboardObjectiveStylingTmp + } + ret.Styling = PlayToClientPacketScoreboardObjectiveStyling0Tmp + case 2: + var PlayToClientPacketScoreboardObjectiveStyling2Tmp any + switch ret.NumberFormat { + case 1: + var PlayToClientPacketScoreboardObjectiveStyling1Tmp nbt.Anon + err = PlayToClientPacketScoreboardObjectiveStyling1Tmp.Decode(r) + if err != nil { + return + } + PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStyling1Tmp + case 2: + var PlayToClientPacketScoreboardObjectiveStyling2Tmp nbt.Anon + err = PlayToClientPacketScoreboardObjectiveStyling2Tmp.Decode(r) + if err != nil { + return + } + PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStyling2Tmp + default: + var PlayToClientPacketScoreboardObjectiveStylingTmp struct { + } + PlayToClientPacketScoreboardObjectiveStyling2Tmp = PlayToClientPacketScoreboardObjectiveStylingTmp + } + ret.Styling = PlayToClientPacketScoreboardObjectiveStyling2Tmp + default: + var PlayToClientPacketScoreboardObjectiveStylingTmp struct { + } + ret.Styling = PlayToClientPacketScoreboardObjectiveStylingTmp + } + return +} +func (ret *PlayToClientPacketScoreboardObjective) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Name) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Action) + if err != nil { + return + } + switch ret.Action { + case 0: + PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketScoreboardObjectiveDisplayText.Encode(w) + if err != nil { + return + } + case 2: + PlayToClientPacketScoreboardObjectiveDisplayText, ok := ret.DisplayText.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketScoreboardObjectiveDisplayText.Encode(w) + if err != nil { + return + } + default: + _, ok := ret.DisplayText.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action { + case 0: + PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketScoreboardObjectiveType) + if err != nil { + return + } + case 2: + PlayToClientPacketScoreboardObjectiveType, ok := ret.Type.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketScoreboardObjectiveType) + if err != nil { + return + } + default: + _, ok := ret.Type.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action { + case 0: + PlayToClientPacketScoreboardObjectiveNumberFormat, ok := ret.NumberFormat.(*int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardObjectiveNumberFormat != nil) + if err != nil { + return + } + if PlayToClientPacketScoreboardObjectiveNumberFormat != nil { + err = proto_base.EncodeVarInt(w, *PlayToClientPacketScoreboardObjectiveNumberFormat) + if err != nil { + return + } + } + case 2: + PlayToClientPacketScoreboardObjectiveNumberFormat, ok := ret.NumberFormat.(*int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketScoreboardObjectiveNumberFormat != nil) + if err != nil { + return + } + if PlayToClientPacketScoreboardObjectiveNumberFormat != nil { + err = proto_base.EncodeVarInt(w, *PlayToClientPacketScoreboardObjectiveNumberFormat) + if err != nil { + return + } + } + default: + _, ok := ret.NumberFormat.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Action { + case 0: + PlayToClientPacketScoreboardObjectiveStyling, ok := ret.Styling.(any) + if !ok { + err = proto_base.BadTypeError + return + } + switch ret.NumberFormat { + case 1: + PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w) + if err != nil { + return + } + case 2: + PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w) + if err != nil { + return + } + default: + _, ok := PlayToClientPacketScoreboardObjectiveStyling.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + case 2: + PlayToClientPacketScoreboardObjectiveStyling, ok := ret.Styling.(any) + if !ok { + err = proto_base.BadTypeError + return + } + switch ret.NumberFormat { + case 1: + PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w) + if err != nil { + return + } + case 2: + PlayToClientPacketScoreboardObjectiveStyling, ok := PlayToClientPacketScoreboardObjectiveStyling.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketScoreboardObjectiveStyling.Encode(w) + if err != nil { + return + } + default: + _, ok := PlayToClientPacketScoreboardObjectiveStyling.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + default: + _, ok := ret.Styling.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + return +} + +type PlayToClientPacketScoreboardScore struct { + ItemName string + ScoreName string + Value int32 + DisplayName *nbt.Anon + NumberFormat *int32 + Styling any +} + +func (ret *PlayToClientPacketScoreboardScore) Decode(r io.Reader) (err error) { + err = proto_base.ToDoError + return +} +func (ret *PlayToClientPacketScoreboardScore) Encode(w io.Writer) (err error) { + err = proto_base.ToDoError + return +} + +type PlayToClientPacketSelectAdvancementTab struct { + Id *string +} + +func (ret *PlayToClientPacketSelectAdvancementTab) Decode(r io.Reader) (err error) { + var PlayToClientPacketSelectAdvancementTabIdPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketSelectAdvancementTabIdPresent) + if err != nil { + return + } + if PlayToClientPacketSelectAdvancementTabIdPresent { + var PlayToClientPacketSelectAdvancementTabIdPresentValue string + PlayToClientPacketSelectAdvancementTabIdPresentValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Id = &PlayToClientPacketSelectAdvancementTabIdPresentValue + } + return +} +func (ret *PlayToClientPacketSelectAdvancementTab) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Id != nil) + if err != nil { + return + } + if ret.Id != nil { + err = proto_base.EncodeString(w, *ret.Id) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketServerData struct { + Motd nbt.Anon + IconBytes *ByteArray +} + +func (ret *PlayToClientPacketServerData) Decode(r io.Reader) (err error) { + err = ret.Motd.Decode(r) + if err != nil { + return + } + var PlayToClientPacketServerDataIconBytesPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketServerDataIconBytesPresent) + if err != nil { + return + } + if PlayToClientPacketServerDataIconBytesPresent { + var PlayToClientPacketServerDataIconBytesPresentValue ByteArray + err = PlayToClientPacketServerDataIconBytesPresentValue.Decode(r) + if err != nil { + return + } + ret.IconBytes = &PlayToClientPacketServerDataIconBytesPresentValue + } + return +} +func (ret *PlayToClientPacketServerData) Encode(w io.Writer) (err error) { + err = ret.Motd.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IconBytes != nil) + if err != nil { + return + } + if ret.IconBytes != nil { + err = (*ret.IconBytes).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketSetCooldown struct { + CooldownGroup string + CooldownTicks int32 +} + +func (ret *PlayToClientPacketSetCooldown) Decode(r io.Reader) (err error) { + ret.CooldownGroup, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.CooldownTicks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSetCooldown) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.CooldownGroup) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.CooldownTicks) + if err != nil { + return + } + return +} + +type PlayToClientPacketSetCursorItem struct { + Contents Slot +} + +func (ret *PlayToClientPacketSetCursorItem) Decode(r io.Reader) (err error) { + err = ret.Contents.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSetCursorItem) Encode(w io.Writer) (err error) { + err = ret.Contents.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketSetPassengers struct { + EntityId int32 + Passengers []int32 +} + +func (ret *PlayToClientPacketSetPassengers) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lPlayToClientPacketSetPassengersPassengers int32 + lPlayToClientPacketSetPassengersPassengers, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Passengers = []int32{} + for range lPlayToClientPacketSetPassengersPassengers { + var PlayToClientPacketSetPassengersPassengersElement int32 + PlayToClientPacketSetPassengersPassengersElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Passengers = append(ret.Passengers, PlayToClientPacketSetPassengersPassengersElement) + } + return +} +func (ret *PlayToClientPacketSetPassengers) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Passengers))) + if err != nil { + return + } + for iPlayToClientPacketSetPassengersPassengers := range len(ret.Passengers) { + err = proto_base.EncodeVarInt(w, ret.Passengers[iPlayToClientPacketSetPassengersPassengers]) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketSetPlayerInventory struct { + SlotId int32 + Contents Slot +} + +func (ret *PlayToClientPacketSetPlayerInventory) Decode(r io.Reader) (err error) { + ret.SlotId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.Contents.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSetPlayerInventory) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.SlotId) + if err != nil { + return + } + err = ret.Contents.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketSetProjectilePower struct { + Id int32 + AccelerationPower float64 +} + +func (ret *PlayToClientPacketSetProjectilePower) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.AccelerationPower) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSetProjectilePower) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.AccelerationPower) + if err != nil { + return + } + return +} + +type PlayToClientPacketSetSlot struct { + WindowId ContainerID + StateId int32 + Slot int16 + Item Slot +} + +func (ret *PlayToClientPacketSetSlot) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + ret.StateId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Slot) + if err != nil { + return + } + err = ret.Item.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSetSlot) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.StateId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Slot) + if err != nil { + return + } + err = ret.Item.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketSetTickingState struct { + TickRate float32 + IsFrozen bool +} + +func (ret *PlayToClientPacketSetTickingState) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.TickRate) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IsFrozen) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSetTickingState) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.TickRate) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IsFrozen) + if err != nil { + return + } + return +} + +type PlayToClientPacketSetTitleSubtitle struct { + Text nbt.Anon +} + +func (ret *PlayToClientPacketSetTitleSubtitle) Decode(r io.Reader) (err error) { + err = ret.Text.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSetTitleSubtitle) Encode(w io.Writer) (err error) { + err = ret.Text.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketSetTitleText struct { + Text nbt.Anon +} + +func (ret *PlayToClientPacketSetTitleText) Decode(r io.Reader) (err error) { + err = ret.Text.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSetTitleText) Encode(w io.Writer) (err error) { + err = ret.Text.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketSetTitleTime struct { + FadeIn int32 + Stay int32 + FadeOut int32 +} + +func (ret *PlayToClientPacketSetTitleTime) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.FadeIn) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Stay) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.FadeOut) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSetTitleTime) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.FadeIn) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Stay) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.FadeOut) + if err != nil { + return + } + return +} + +type PlayToClientPacketShowDialog struct { + Dialog any +} + +func (ret *PlayToClientPacketShowDialog) Decode(r io.Reader) (err error) { + var PlayToClientPacketShowDialogDialogId int32 + PlayToClientPacketShowDialogDialogId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + if PlayToClientPacketShowDialogDialogId != 0 { + ret.Dialog = PlayToClientPacketShowDialogDialogId + } else { + var PlayToClientPacketShowDialogDialogResult nbt.Anon + err = PlayToClientPacketShowDialogDialogResult.Decode(r) + if err != nil { + return + } + ret.Dialog = PlayToClientPacketShowDialogDialogResult + } + return +} +func (ret *PlayToClientPacketShowDialog) Encode(w io.Writer) (err error) { + switch PlayToClientPacketShowDialogDialogKnownType := ret.Dialog.(type) { + case int32: + err = proto_base.EncodeVarInt(w, PlayToClientPacketShowDialogDialogKnownType) + if err != nil { + return + } + case nbt.Anon: + err = proto_base.EncodeVarInt(w, 0) + if err != nil { + return + } + err = PlayToClientPacketShowDialogDialogKnownType.Encode(w) + if err != nil { + return + } + default: + err = proto_base.BadTypeError + } + return +} + +type PlayToClientPacketSimulationDistance struct { + Distance int32 +} + +func (ret *PlayToClientPacketSimulationDistance) Decode(r io.Reader) (err error) { + ret.Distance, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSimulationDistance) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Distance) + if err != nil { + return + } + return +} + +type PlayToClientPacketSoundEffect struct { + Sound ItemSoundHolder + SoundCategory SoundSource + X int32 + Y int32 + Z int32 + Volume float32 + Pitch float32 + Seed int64 +} + +func (ret *PlayToClientPacketSoundEffect) Decode(r io.Reader) (err error) { + err = ret.Sound.Decode(r) + if err != nil { + return + } + err = ret.SoundCategory.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Volume) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Seed) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSoundEffect) Encode(w io.Writer) (err error) { + err = ret.Sound.Encode(w) + if err != nil { + return + } + err = ret.SoundCategory.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Volume) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Seed) + if err != nil { + return + } + return +} + +type PlayToClientPacketSpawnEntity struct { + EntityId int32 + ObjectUUID uuid.UUID + Type int32 + X float64 + Y float64 + Z float64 + Pitch int8 + Yaw int8 + HeadPitch int8 + ObjectData int32 + VelocityX int16 + VelocityY int16 + VelocityZ int16 +} + +func (ret *PlayToClientPacketSpawnEntity) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + _, err = io.ReadFull(r, ret.ObjectUUID[:]) + if err != nil { + return + } + ret.Type, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.HeadPitch) + if err != nil { + return + } + ret.ObjectData, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.VelocityX) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.VelocityY) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.VelocityZ) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSpawnEntity) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + _, err = w.Write(ret.ObjectUUID[:]) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Type) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.HeadPitch) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ObjectData) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.VelocityX) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.VelocityY) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.VelocityZ) + if err != nil { + return + } + return +} + +type PlayToClientPacketSpawnPosition struct { + Location Position + Angle float32 +} + +func (ret *PlayToClientPacketSpawnPosition) Decode(r io.Reader) (err error) { + err = ret.Location.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Angle) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSpawnPosition) Encode(w io.Writer) (err error) { + err = ret.Location.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Angle) + if err != nil { + return + } + return +} + +type PlayToClientPacketStartConfiguration struct { +} + +func (ret *PlayToClientPacketStartConfiguration) Decode(r io.Reader) (err error) { + return +} +func (ret *PlayToClientPacketStartConfiguration) Encode(w io.Writer) (err error) { + return +} + +type PlayToClientPacketStatistics struct { + Entries []struct { + CategoryId int32 + StatisticId int32 + Value int32 + } +} + +func (ret *PlayToClientPacketStatistics) Decode(r io.Reader) (err error) { + var lPlayToClientPacketStatisticsEntries int32 + lPlayToClientPacketStatisticsEntries, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Entries = []struct { + CategoryId int32 + StatisticId int32 + Value int32 + }{} + for range lPlayToClientPacketStatisticsEntries { + var PlayToClientPacketStatisticsEntriesElement struct { + CategoryId int32 + StatisticId int32 + Value int32 + } + PlayToClientPacketStatisticsEntriesElement.CategoryId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketStatisticsEntriesElement.StatisticId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketStatisticsEntriesElement.Value, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Entries = append(ret.Entries, PlayToClientPacketStatisticsEntriesElement) + } + return +} +func (ret *PlayToClientPacketStatistics) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Entries))) + if err != nil { + return + } + for iPlayToClientPacketStatisticsEntries := range len(ret.Entries) { + err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].CategoryId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].StatisticId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Entries[iPlayToClientPacketStatisticsEntries].Value) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketStepTick struct { + TickSteps int32 +} + +func (ret *PlayToClientPacketStepTick) Decode(r io.Reader) (err error) { + ret.TickSteps, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketStepTick) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.TickSteps) + if err != nil { + return + } + return +} + +type PlayToClientPacketStopSound struct { + Flags int8 + Source any + Sound any +} + +func (ret *PlayToClientPacketStopSound) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Flags) + if err != nil { + return + } + switch ret.Flags { + case 1: + var PlayToClientPacketStopSoundSource1Tmp int32 + PlayToClientPacketStopSoundSource1Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Source = PlayToClientPacketStopSoundSource1Tmp + case 3: + var PlayToClientPacketStopSoundSource3Tmp int32 + PlayToClientPacketStopSoundSource3Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Source = PlayToClientPacketStopSoundSource3Tmp + default: + var PlayToClientPacketStopSoundSourceTmp struct { + } + ret.Source = PlayToClientPacketStopSoundSourceTmp + } + switch ret.Flags { + case 2: + var PlayToClientPacketStopSoundSound2Tmp string + PlayToClientPacketStopSoundSound2Tmp, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Sound = PlayToClientPacketStopSoundSound2Tmp + case 3: + var PlayToClientPacketStopSoundSound3Tmp string + PlayToClientPacketStopSoundSound3Tmp, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Sound = PlayToClientPacketStopSoundSound3Tmp + default: + var PlayToClientPacketStopSoundSoundTmp struct { + } + ret.Sound = PlayToClientPacketStopSoundSoundTmp + } + return +} +func (ret *PlayToClientPacketStopSound) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Flags) + if err != nil { + return + } + switch ret.Flags { + case 1: + PlayToClientPacketStopSoundSource, ok := ret.Source.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketStopSoundSource) + if err != nil { + return + } + case 3: + PlayToClientPacketStopSoundSource, ok := ret.Source.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketStopSoundSource) + if err != nil { + return + } + default: + _, ok := ret.Source.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Flags { + case 2: + PlayToClientPacketStopSoundSound, ok := ret.Sound.(string) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, PlayToClientPacketStopSoundSound) + if err != nil { + return + } + case 3: + PlayToClientPacketStopSoundSound, ok := ret.Sound.(string) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, PlayToClientPacketStopSoundSound) + if err != nil { + return + } + default: + _, ok := ret.Sound.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + return +} + +type PlayToClientPacketSyncEntityPosition struct { + EntityId int32 + X float64 + Y float64 + Z float64 + Dx float64 + Dy float64 + Dz float64 + Yaw float32 + Pitch float32 + OnGround bool +} + +func (ret *PlayToClientPacketSyncEntityPosition) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Dx) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Dy) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Dz) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OnGround) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSyncEntityPosition) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Dx) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Dy) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Dz) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OnGround) + if err != nil { + return + } + return +} + +type PlayToClientPacketSystemChat struct { + Content nbt.Anon + IsActionBar bool +} + +func (ret *PlayToClientPacketSystemChat) Decode(r io.Reader) (err error) { + err = ret.Content.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IsActionBar) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketSystemChat) Encode(w io.Writer) (err error) { + err = ret.Content.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IsActionBar) + if err != nil { + return + } + return +} + +type PlayToClientPacketTabComplete struct { + TransactionId int32 + Start int32 + Length int32 + Matches []struct { + Match string + Tooltip *nbt.Anon + } +} + +func (ret *PlayToClientPacketTabComplete) Decode(r io.Reader) (err error) { + ret.TransactionId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Start, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Length, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lPlayToClientPacketTabCompleteMatches int32 + lPlayToClientPacketTabCompleteMatches, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Matches = []struct { + Match string + Tooltip *nbt.Anon + }{} + for range lPlayToClientPacketTabCompleteMatches { + var PlayToClientPacketTabCompleteMatchesElement struct { + Match string + Tooltip *nbt.Anon + } + PlayToClientPacketTabCompleteMatchesElement.Match, err = proto_base.DecodeString(r) + if err != nil { + return + } + var PlayToClientPacketTabCompleteMatchesElementTooltipPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTabCompleteMatchesElementTooltipPresent) + if err != nil { + return + } + if PlayToClientPacketTabCompleteMatchesElementTooltipPresent { + var PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue nbt.Anon + err = PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue.Decode(r) + if err != nil { + return + } + PlayToClientPacketTabCompleteMatchesElement.Tooltip = &PlayToClientPacketTabCompleteMatchesElementTooltipPresentValue + } + ret.Matches = append(ret.Matches, PlayToClientPacketTabCompleteMatchesElement) + } + return +} +func (ret *PlayToClientPacketTabComplete) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.TransactionId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Start) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Length) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Matches))) + if err != nil { + return + } + for iPlayToClientPacketTabCompleteMatches := range len(ret.Matches) { + err = proto_base.EncodeString(w, ret.Matches[iPlayToClientPacketTabCompleteMatches].Match) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil) + if err != nil { + return + } + if ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip != nil { + err = (*ret.Matches[iPlayToClientPacketTabCompleteMatches].Tooltip).Encode(w) + if err != nil { + return + } + } + } + return +} + +type PlayToClientPacketTags struct { + Tags []struct { + TagType string + Tags Tags + } +} + +func (ret *PlayToClientPacketTags) Decode(r io.Reader) (err error) { + var lPlayToClientPacketTagsTags int32 + lPlayToClientPacketTagsTags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Tags = []struct { + TagType string + Tags Tags + }{} + for range lPlayToClientPacketTagsTags { + var PlayToClientPacketTagsTagsElement struct { + TagType string + Tags Tags + } + PlayToClientPacketTagsTagsElement.TagType, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = PlayToClientPacketTagsTagsElement.Tags.Decode(r) + if err != nil { + return + } + ret.Tags = append(ret.Tags, PlayToClientPacketTagsTagsElement) + } + return +} +func (ret *PlayToClientPacketTags) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Tags))) + if err != nil { + return + } + for iPlayToClientPacketTagsTags := range len(ret.Tags) { + err = proto_base.EncodeString(w, ret.Tags[iPlayToClientPacketTagsTags].TagType) + if err != nil { + return + } + err = ret.Tags[iPlayToClientPacketTagsTags].Tags.Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketTeams struct { + Team string + Mode string + Anon any + Players any +} + +var PlayToClientPacketTeamsModeMap = map[int8]string{0: "add", 1: "remove", 2: "change", 3: "join", 4: "leave"} +var PlayToClientPacketTeamsAnonNameTagVisibilityMap = map[int32]string{0: "always", 1: "never", 2: "hide_for_other_teams", 3: "hide_for_own_team"} +var PlayToClientPacketTeamsAnonCollisionRuleMap = map[int32]string{0: "always", 1: "never", 2: "push_other_teams", 3: "push_own_team"} + +func (ret *PlayToClientPacketTeams) Decode(r io.Reader) (err error) { + ret.Team, err = proto_base.DecodeString(r) + if err != nil { + return + } + var PlayToClientPacketTeamsModeKey int8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsModeKey) + if err != nil { + return + } + ret.Mode, err = proto_base.ErroringIndex(PlayToClientPacketTeamsModeMap, PlayToClientPacketTeamsModeKey) + if err != nil { + return + } + switch ret.Mode { + case "add": + var PlayToClientPacketTeamsAnonAddTmp struct { + Name nbt.Anon + Flags uint8 + NameTagVisibility string + CollisionRule string + Formatting int32 + Prefix nbt.Anon + Suffix nbt.Anon + } + err = PlayToClientPacketTeamsAnonAddTmp.Name.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsAnonAddTmp.Flags) + if err != nil { + return + } + var PlayToClientPacketTeamsAnonNameTagVisibilityKey int32 + PlayToClientPacketTeamsAnonNameTagVisibilityKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketTeamsAnonAddTmp.NameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityMap, PlayToClientPacketTeamsAnonNameTagVisibilityKey) + if err != nil { + return + } + var PlayToClientPacketTeamsAnonCollisionRuleKey int32 + PlayToClientPacketTeamsAnonCollisionRuleKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketTeamsAnonAddTmp.CollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleMap, PlayToClientPacketTeamsAnonCollisionRuleKey) + if err != nil { + return + } + PlayToClientPacketTeamsAnonAddTmp.Formatting, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = PlayToClientPacketTeamsAnonAddTmp.Prefix.Decode(r) + if err != nil { + return + } + err = PlayToClientPacketTeamsAnonAddTmp.Suffix.Decode(r) + if err != nil { + return + } + ret.Anon = PlayToClientPacketTeamsAnonAddTmp + case "change": + var PlayToClientPacketTeamsAnonChangeTmp struct { + Name nbt.Anon + Flags uint8 + NameTagVisibility string + CollisionRule string + Formatting int32 + Prefix nbt.Anon + Suffix nbt.Anon + } + err = PlayToClientPacketTeamsAnonChangeTmp.Name.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTeamsAnonChangeTmp.Flags) + if err != nil { + return + } + var PlayToClientPacketTeamsAnonNameTagVisibilityKey int32 + PlayToClientPacketTeamsAnonNameTagVisibilityKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketTeamsAnonChangeTmp.NameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityMap, PlayToClientPacketTeamsAnonNameTagVisibilityKey) + if err != nil { + return + } + var PlayToClientPacketTeamsAnonCollisionRuleKey int32 + PlayToClientPacketTeamsAnonCollisionRuleKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketTeamsAnonChangeTmp.CollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleMap, PlayToClientPacketTeamsAnonCollisionRuleKey) + if err != nil { + return + } + PlayToClientPacketTeamsAnonChangeTmp.Formatting, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = PlayToClientPacketTeamsAnonChangeTmp.Prefix.Decode(r) + if err != nil { + return + } + err = PlayToClientPacketTeamsAnonChangeTmp.Suffix.Decode(r) + if err != nil { + return + } + ret.Anon = PlayToClientPacketTeamsAnonChangeTmp + default: + var PlayToClientPacketTeamsAnonTmp struct { + } + ret.Anon = PlayToClientPacketTeamsAnonTmp + } + switch ret.Mode { + case "add": + var PlayToClientPacketTeamsPlayersAddTmp []string + var lPlayToClientPacketTeamsPlayers int32 + lPlayToClientPacketTeamsPlayers, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketTeamsPlayersAddTmp = []string{} + for range lPlayToClientPacketTeamsPlayers { + var PlayToClientPacketTeamsPlayersElement string + PlayToClientPacketTeamsPlayersElement, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToClientPacketTeamsPlayersAddTmp = append(PlayToClientPacketTeamsPlayersAddTmp, PlayToClientPacketTeamsPlayersElement) + } + ret.Players = PlayToClientPacketTeamsPlayersAddTmp + case "join": + var PlayToClientPacketTeamsPlayersJoinTmp []string + var lPlayToClientPacketTeamsPlayers int32 + lPlayToClientPacketTeamsPlayers, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketTeamsPlayersJoinTmp = []string{} + for range lPlayToClientPacketTeamsPlayers { + var PlayToClientPacketTeamsPlayersElement string + PlayToClientPacketTeamsPlayersElement, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToClientPacketTeamsPlayersJoinTmp = append(PlayToClientPacketTeamsPlayersJoinTmp, PlayToClientPacketTeamsPlayersElement) + } + ret.Players = PlayToClientPacketTeamsPlayersJoinTmp + case "leave": + var PlayToClientPacketTeamsPlayersLeaveTmp []string + var lPlayToClientPacketTeamsPlayers int32 + lPlayToClientPacketTeamsPlayers, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketTeamsPlayersLeaveTmp = []string{} + for range lPlayToClientPacketTeamsPlayers { + var PlayToClientPacketTeamsPlayersElement string + PlayToClientPacketTeamsPlayersElement, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToClientPacketTeamsPlayersLeaveTmp = append(PlayToClientPacketTeamsPlayersLeaveTmp, PlayToClientPacketTeamsPlayersElement) + } + ret.Players = PlayToClientPacketTeamsPlayersLeaveTmp + default: + var PlayToClientPacketTeamsPlayersTmp struct { + } + ret.Players = PlayToClientPacketTeamsPlayersTmp + } + return +} + +var PlayToClientPacketTeamsModeReverseMap = map[string]int8{"add": 0, "remove": 1, "change": 2, "join": 3, "leave": 4} +var PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap = map[string]int32{"always": 0, "never": 1, "hide_for_other_teams": 2, "hide_for_own_team": 3} +var PlayToClientPacketTeamsAnonCollisionRuleReverseMap = map[string]int32{"always": 0, "never": 1, "push_other_teams": 2, "push_own_team": 3} + +func (ret *PlayToClientPacketTeams) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Team) + if err != nil { + return + } + var vPlayToClientPacketTeamsMode int8 + vPlayToClientPacketTeamsMode, err = proto_base.ErroringIndex(PlayToClientPacketTeamsModeReverseMap, ret.Mode) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, vPlayToClientPacketTeamsMode) + if err != nil { + return + } + switch ret.Mode { + case "add": + PlayToClientPacketTeamsAnon, ok := ret.Anon.(struct { + Name nbt.Anon + Flags uint8 + NameTagVisibility string + CollisionRule string + Formatting int32 + Prefix nbt.Anon + Suffix nbt.Anon + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketTeamsAnon.Name.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsAnon.Flags) + if err != nil { + return + } + var vPlayToClientPacketTeamsAnonNameTagVisibility int32 + vPlayToClientPacketTeamsAnonNameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap, PlayToClientPacketTeamsAnon.NameTagVisibility) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonNameTagVisibility) + if err != nil { + return + } + var vPlayToClientPacketTeamsAnonCollisionRule int32 + vPlayToClientPacketTeamsAnonCollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleReverseMap, PlayToClientPacketTeamsAnon.CollisionRule) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonCollisionRule) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsAnon.Formatting) + if err != nil { + return + } + err = PlayToClientPacketTeamsAnon.Prefix.Encode(w) + if err != nil { + return + } + err = PlayToClientPacketTeamsAnon.Suffix.Encode(w) + if err != nil { + return + } + case "change": + PlayToClientPacketTeamsAnon, ok := ret.Anon.(struct { + Name nbt.Anon + Flags uint8 + NameTagVisibility string + CollisionRule string + Formatting int32 + Prefix nbt.Anon + Suffix nbt.Anon + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketTeamsAnon.Name.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketTeamsAnon.Flags) + if err != nil { + return + } + var vPlayToClientPacketTeamsAnonNameTagVisibility int32 + vPlayToClientPacketTeamsAnonNameTagVisibility, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonNameTagVisibilityReverseMap, PlayToClientPacketTeamsAnon.NameTagVisibility) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonNameTagVisibility) + if err != nil { + return + } + var vPlayToClientPacketTeamsAnonCollisionRule int32 + vPlayToClientPacketTeamsAnonCollisionRule, err = proto_base.ErroringIndex(PlayToClientPacketTeamsAnonCollisionRuleReverseMap, PlayToClientPacketTeamsAnon.CollisionRule) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketTeamsAnonCollisionRule) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketTeamsAnon.Formatting) + if err != nil { + return + } + err = PlayToClientPacketTeamsAnon.Prefix.Encode(w) + if err != nil { + return + } + err = PlayToClientPacketTeamsAnon.Suffix.Encode(w) + if err != nil { + return + } + default: + _, ok := ret.Anon.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Mode { + case "add": + PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers))) + if err != nil { + return + } + for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) { + err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers]) + if err != nil { + return + } + } + case "join": + PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers))) + if err != nil { + return + } + for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) { + err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers]) + if err != nil { + return + } + } + case "leave": + PlayToClientPacketTeamsPlayers, ok := ret.Players.([]string) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, int32(len(PlayToClientPacketTeamsPlayers))) + if err != nil { + return + } + for iPlayToClientPacketTeamsPlayers := range len(PlayToClientPacketTeamsPlayers) { + err = proto_base.EncodeString(w, PlayToClientPacketTeamsPlayers[iPlayToClientPacketTeamsPlayers]) + if err != nil { + return + } + } + default: + _, ok := ret.Players.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + return +} + +type PlayToClientPacketTestInstanceBlockStatus struct { + Status nbt.Anon + Size *Vec3i +} + +func (ret *PlayToClientPacketTestInstanceBlockStatus) Decode(r io.Reader) (err error) { + err = ret.Status.Decode(r) + if err != nil { + return + } + var PlayToClientPacketTestInstanceBlockStatusSizePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTestInstanceBlockStatusSizePresent) + if err != nil { + return + } + if PlayToClientPacketTestInstanceBlockStatusSizePresent { + var PlayToClientPacketTestInstanceBlockStatusSizePresentValue Vec3i + err = PlayToClientPacketTestInstanceBlockStatusSizePresentValue.Decode(r) + if err != nil { + return + } + ret.Size = &PlayToClientPacketTestInstanceBlockStatusSizePresentValue + } + return +} +func (ret *PlayToClientPacketTestInstanceBlockStatus) Encode(w io.Writer) (err error) { + err = ret.Status.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Size != nil) + if err != nil { + return + } + if ret.Size != nil { + err = (*ret.Size).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketTileEntityData struct { + Location Position + Action int32 + NbtData nbt.Anon +} + +func (ret *PlayToClientPacketTileEntityData) Decode(r io.Reader) (err error) { + err = ret.Location.Decode(r) + if err != nil { + return + } + ret.Action, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.NbtData.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketTileEntityData) Encode(w io.Writer) (err error) { + err = ret.Location.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Action) + if err != nil { + return + } + err = ret.NbtData.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketTrackedWaypoint struct { + Operation string + Waypoint struct { + HasUUID bool + Anon any + Icon struct { + Style string + Color *int32 + } + Type string + Data any + } +} + +var PlayToClientPacketTrackedWaypointOperationMap = map[int32]string{0: "track", 1: "untrack", 2: "update"} +var PlayToClientPacketTrackedWaypointWaypointTypeMap = map[int32]string{0: "empty", 1: "vec3i", 2: "chunk", 3: "azimuth"} + +func (ret *PlayToClientPacketTrackedWaypoint) Decode(r io.Reader) (err error) { + var PlayToClientPacketTrackedWaypointOperationKey int32 + PlayToClientPacketTrackedWaypointOperationKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Operation, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointOperationMap, PlayToClientPacketTrackedWaypointOperationKey) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Waypoint.HasUUID) + if err != nil { + return + } + switch ret.Waypoint.HasUUID { + case false: + var PlayToClientPacketTrackedWaypointWaypointAnonFalseTmp struct { + Id string + } + PlayToClientPacketTrackedWaypointWaypointAnonFalseTmp.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Waypoint.Anon = PlayToClientPacketTrackedWaypointWaypointAnonFalseTmp + case true: + var PlayToClientPacketTrackedWaypointWaypointAnonTrueTmp struct { + Uuid uuid.UUID + } + _, err = io.ReadFull(r, PlayToClientPacketTrackedWaypointWaypointAnonTrueTmp.Uuid[:]) + if err != nil { + return + } + ret.Waypoint.Anon = PlayToClientPacketTrackedWaypointWaypointAnonTrueTmp + } + ret.Waypoint.Icon.Style, err = proto_base.DecodeString(r) + if err != nil { + return + } + var PlayToClientPacketTrackedWaypointWaypointIconColorPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresent) + if err != nil { + return + } + if PlayToClientPacketTrackedWaypointWaypointIconColorPresent { + var PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue int32 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue) + if err != nil { + return + } + ret.Waypoint.Icon.Color = &PlayToClientPacketTrackedWaypointWaypointIconColorPresentValue + } + var PlayToClientPacketTrackedWaypointWaypointTypeKey int32 + PlayToClientPacketTrackedWaypointWaypointTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Waypoint.Type, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointWaypointTypeMap, PlayToClientPacketTrackedWaypointWaypointTypeKey) + if err != nil { + return + } + switch ret.Waypoint.Type { + case "azimuth": + var PlayToClientPacketTrackedWaypointWaypointDataAzimuthTmp float32 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTrackedWaypointWaypointDataAzimuthTmp) + if err != nil { + return + } + ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataAzimuthTmp + case "chunk": + var PlayToClientPacketTrackedWaypointWaypointDataChunkTmp struct { + ChunkX int32 + ChunkZ int32 + } + PlayToClientPacketTrackedWaypointWaypointDataChunkTmp.ChunkX, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketTrackedWaypointWaypointDataChunkTmp.ChunkZ, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataChunkTmp + case "vec3i": + var PlayToClientPacketTrackedWaypointWaypointDataVec3iTmp Vec3i + err = PlayToClientPacketTrackedWaypointWaypointDataVec3iTmp.Decode(r) + if err != nil { + return + } + ret.Waypoint.Data = PlayToClientPacketTrackedWaypointWaypointDataVec3iTmp + } + return +} + +var PlayToClientPacketTrackedWaypointOperationReverseMap = map[string]int32{"track": 0, "untrack": 1, "update": 2} +var PlayToClientPacketTrackedWaypointWaypointTypeReverseMap = map[string]int32{"empty": 0, "vec3i": 1, "chunk": 2, "azimuth": 3} + +func (ret *PlayToClientPacketTrackedWaypoint) Encode(w io.Writer) (err error) { + var vPlayToClientPacketTrackedWaypointOperation int32 + vPlayToClientPacketTrackedWaypointOperation, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointOperationReverseMap, ret.Operation) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketTrackedWaypointOperation) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Waypoint.HasUUID) + if err != nil { + return + } + switch ret.Waypoint.HasUUID { + case false: + PlayToClientPacketTrackedWaypointWaypointAnon, ok := ret.Waypoint.Anon.(struct { + Id string + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, PlayToClientPacketTrackedWaypointWaypointAnon.Id) + if err != nil { + return + } + case true: + PlayToClientPacketTrackedWaypointWaypointAnon, ok := ret.Waypoint.Anon.(struct { + Uuid uuid.UUID + }) + if !ok { + err = proto_base.BadTypeError + return + } + _, err = w.Write(PlayToClientPacketTrackedWaypointWaypointAnon.Uuid[:]) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Waypoint.Icon.Style) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Waypoint.Icon.Color != nil) + if err != nil { + return + } + if ret.Waypoint.Icon.Color != nil { + err = binary.Write(w, binary.BigEndian, *ret.Waypoint.Icon.Color) + if err != nil { + return + } + } + var vPlayToClientPacketTrackedWaypointWaypointType int32 + vPlayToClientPacketTrackedWaypointWaypointType, err = proto_base.ErroringIndex(PlayToClientPacketTrackedWaypointWaypointTypeReverseMap, ret.Waypoint.Type) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToClientPacketTrackedWaypointWaypointType) + if err != nil { + return + } + switch ret.Waypoint.Type { + case "azimuth": + PlayToClientPacketTrackedWaypointWaypointData, ok := ret.Waypoint.Data.(float32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToClientPacketTrackedWaypointWaypointData) + if err != nil { + return + } + case "chunk": + PlayToClientPacketTrackedWaypointWaypointData, ok := ret.Waypoint.Data.(struct { + ChunkX int32 + ChunkZ int32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketTrackedWaypointWaypointData.ChunkX) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, PlayToClientPacketTrackedWaypointWaypointData.ChunkZ) + if err != nil { + return + } + case "vec3i": + PlayToClientPacketTrackedWaypointWaypointData, ok := ret.Waypoint.Data.(Vec3i) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToClientPacketTrackedWaypointWaypointData.Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToClientPacketTradeList struct { + WindowId ContainerID + Trades []struct { + InputItem1 struct { + ItemId int32 + ItemCount int32 + Components ExactComponentMatcher + } + OutputItem Slot + InputItem2 *struct { + ItemId int32 + ItemCount int32 + Components ExactComponentMatcher + } + TradeDisabled bool + NbTradeUses int32 + MaximumNbTradeUses int32 + Xp int32 + SpecialPrice int32 + PriceMultiplier float32 + Demand int32 + } + VillagerLevel int32 + Experience int32 + IsRegularVillager bool + CanRestock bool +} + +func (ret *PlayToClientPacketTradeList) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + var lPlayToClientPacketTradeListTrades int32 + lPlayToClientPacketTradeListTrades, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Trades = []struct { + InputItem1 struct { + ItemId int32 + ItemCount int32 + Components ExactComponentMatcher + } + OutputItem Slot + InputItem2 *struct { + ItemId int32 + ItemCount int32 + Components ExactComponentMatcher + } + TradeDisabled bool + NbTradeUses int32 + MaximumNbTradeUses int32 + Xp int32 + SpecialPrice int32 + PriceMultiplier float32 + Demand int32 + }{} + for range lPlayToClientPacketTradeListTrades { + var PlayToClientPacketTradeListTradesElement struct { + InputItem1 struct { + ItemId int32 + ItemCount int32 + Components ExactComponentMatcher + } + OutputItem Slot + InputItem2 *struct { + ItemId int32 + ItemCount int32 + Components ExactComponentMatcher + } + TradeDisabled bool + NbTradeUses int32 + MaximumNbTradeUses int32 + Xp int32 + SpecialPrice int32 + PriceMultiplier float32 + Demand int32 + } + PlayToClientPacketTradeListTradesElement.InputItem1.ItemId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketTradeListTradesElement.InputItem1.ItemCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = PlayToClientPacketTradeListTradesElement.InputItem1.Components.Decode(r) + if err != nil { + return + } + err = PlayToClientPacketTradeListTradesElement.OutputItem.Decode(r) + if err != nil { + return + } + var PlayToClientPacketTradeListTradesElementInputItem2Present bool + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElementInputItem2Present) + if err != nil { + return + } + if PlayToClientPacketTradeListTradesElementInputItem2Present { + var PlayToClientPacketTradeListTradesElementInputItem2PresentValue struct { + ItemId int32 + ItemCount int32 + Components ExactComponentMatcher + } + PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketTradeListTradesElementInputItem2PresentValue.ItemCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = PlayToClientPacketTradeListTradesElementInputItem2PresentValue.Components.Decode(r) + if err != nil { + return + } + PlayToClientPacketTradeListTradesElement.InputItem2 = &PlayToClientPacketTradeListTradesElementInputItem2PresentValue + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.TradeDisabled) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.NbTradeUses) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.MaximumNbTradeUses) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.Xp) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.SpecialPrice) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.PriceMultiplier) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketTradeListTradesElement.Demand) + if err != nil { + return + } + ret.Trades = append(ret.Trades, PlayToClientPacketTradeListTradesElement) + } + ret.VillagerLevel, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Experience, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IsRegularVillager) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.CanRestock) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketTradeList) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Trades))) + if err != nil { + return + } + for iPlayToClientPacketTradeListTrades := range len(ret.Trades) { + err = proto_base.EncodeVarInt(w, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.ItemId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.ItemCount) + if err != nil { + return + } + err = ret.Trades[iPlayToClientPacketTradeListTrades].InputItem1.Components.Encode(w) + if err != nil { + return + } + err = ret.Trades[iPlayToClientPacketTradeListTrades].OutputItem.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2 != nil) + if err != nil { + return + } + if ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2 != nil { + err = proto_base.EncodeVarInt(w, (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).ItemId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).ItemCount) + if err != nil { + return + } + err = (*ret.Trades[iPlayToClientPacketTradeListTrades].InputItem2).Components.Encode(w) + if err != nil { + return + } + } + err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].TradeDisabled) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].NbTradeUses) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].MaximumNbTradeUses) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].Xp) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].SpecialPrice) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].PriceMultiplier) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Trades[iPlayToClientPacketTradeListTrades].Demand) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, ret.VillagerLevel) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Experience) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IsRegularVillager) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.CanRestock) + if err != nil { + return + } + return +} + +type PlayToClientPacketUnloadChunk struct { + ChunkZ int32 + ChunkX int32 +} + +func (ret *PlayToClientPacketUnloadChunk) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.ChunkZ) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChunkX) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketUnloadChunk) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.ChunkZ) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChunkX) + if err != nil { + return + } + return +} + +type PlayToClientPacketUpdateHealth struct { + Health float32 + Food int32 + FoodSaturation float32 +} + +func (ret *PlayToClientPacketUpdateHealth) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Health) + if err != nil { + return + } + ret.Food, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.FoodSaturation) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketUpdateHealth) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Health) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Food) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.FoodSaturation) + if err != nil { + return + } + return +} + +type PlayToClientPacketUpdateLight struct { + ChunkX int32 + ChunkZ int32 + SkyLightMask []int64 + BlockLightMask []int64 + EmptySkyLightMask []int64 + EmptyBlockLightMask []int64 + SkyLight [][]uint8 + BlockLight [][]uint8 +} + +func (ret *PlayToClientPacketUpdateLight) Decode(r io.Reader) (err error) { + ret.ChunkX, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ChunkZ, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lPlayToClientPacketUpdateLightSkyLightMask int32 + lPlayToClientPacketUpdateLightSkyLightMask, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SkyLightMask = []int64{} + for range lPlayToClientPacketUpdateLightSkyLightMask { + var PlayToClientPacketUpdateLightSkyLightMaskElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightSkyLightMaskElement) + if err != nil { + return + } + ret.SkyLightMask = append(ret.SkyLightMask, PlayToClientPacketUpdateLightSkyLightMaskElement) + } + var lPlayToClientPacketUpdateLightBlockLightMask int32 + lPlayToClientPacketUpdateLightBlockLightMask, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.BlockLightMask = []int64{} + for range lPlayToClientPacketUpdateLightBlockLightMask { + var PlayToClientPacketUpdateLightBlockLightMaskElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightBlockLightMaskElement) + if err != nil { + return + } + ret.BlockLightMask = append(ret.BlockLightMask, PlayToClientPacketUpdateLightBlockLightMaskElement) + } + var lPlayToClientPacketUpdateLightEmptySkyLightMask int32 + lPlayToClientPacketUpdateLightEmptySkyLightMask, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EmptySkyLightMask = []int64{} + for range lPlayToClientPacketUpdateLightEmptySkyLightMask { + var PlayToClientPacketUpdateLightEmptySkyLightMaskElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightEmptySkyLightMaskElement) + if err != nil { + return + } + ret.EmptySkyLightMask = append(ret.EmptySkyLightMask, PlayToClientPacketUpdateLightEmptySkyLightMaskElement) + } + var lPlayToClientPacketUpdateLightEmptyBlockLightMask int32 + lPlayToClientPacketUpdateLightEmptyBlockLightMask, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EmptyBlockLightMask = []int64{} + for range lPlayToClientPacketUpdateLightEmptyBlockLightMask { + var PlayToClientPacketUpdateLightEmptyBlockLightMaskElement int64 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightEmptyBlockLightMaskElement) + if err != nil { + return + } + ret.EmptyBlockLightMask = append(ret.EmptyBlockLightMask, PlayToClientPacketUpdateLightEmptyBlockLightMaskElement) + } + var lPlayToClientPacketUpdateLightSkyLight int32 + lPlayToClientPacketUpdateLightSkyLight, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SkyLight = [][]uint8{} + for range lPlayToClientPacketUpdateLightSkyLight { + var PlayToClientPacketUpdateLightSkyLightElement []uint8 + var lPlayToClientPacketUpdateLightSkyLightElement int32 + lPlayToClientPacketUpdateLightSkyLightElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketUpdateLightSkyLightElement = []uint8{} + for range lPlayToClientPacketUpdateLightSkyLightElement { + var PlayToClientPacketUpdateLightSkyLightElementElement uint8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightSkyLightElementElement) + if err != nil { + return + } + PlayToClientPacketUpdateLightSkyLightElement = append(PlayToClientPacketUpdateLightSkyLightElement, PlayToClientPacketUpdateLightSkyLightElementElement) + } + ret.SkyLight = append(ret.SkyLight, PlayToClientPacketUpdateLightSkyLightElement) + } + var lPlayToClientPacketUpdateLightBlockLight int32 + lPlayToClientPacketUpdateLightBlockLight, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.BlockLight = [][]uint8{} + for range lPlayToClientPacketUpdateLightBlockLight { + var PlayToClientPacketUpdateLightBlockLightElement []uint8 + var lPlayToClientPacketUpdateLightBlockLightElement int32 + lPlayToClientPacketUpdateLightBlockLightElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + PlayToClientPacketUpdateLightBlockLightElement = []uint8{} + for range lPlayToClientPacketUpdateLightBlockLightElement { + var PlayToClientPacketUpdateLightBlockLightElementElement uint8 + err = binary.Read(r, binary.BigEndian, &PlayToClientPacketUpdateLightBlockLightElementElement) + if err != nil { + return + } + PlayToClientPacketUpdateLightBlockLightElement = append(PlayToClientPacketUpdateLightBlockLightElement, PlayToClientPacketUpdateLightBlockLightElementElement) + } + ret.BlockLight = append(ret.BlockLight, PlayToClientPacketUpdateLightBlockLightElement) + } + return +} +func (ret *PlayToClientPacketUpdateLight) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.ChunkX) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChunkZ) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLightMask))) + if err != nil { + return + } + for iPlayToClientPacketUpdateLightSkyLightMask := range len(ret.SkyLightMask) { + err = binary.Write(w, binary.BigEndian, ret.SkyLightMask[iPlayToClientPacketUpdateLightSkyLightMask]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLightMask))) + if err != nil { + return + } + for iPlayToClientPacketUpdateLightBlockLightMask := range len(ret.BlockLightMask) { + err = binary.Write(w, binary.BigEndian, ret.BlockLightMask[iPlayToClientPacketUpdateLightBlockLightMask]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.EmptySkyLightMask))) + if err != nil { + return + } + for iPlayToClientPacketUpdateLightEmptySkyLightMask := range len(ret.EmptySkyLightMask) { + err = binary.Write(w, binary.BigEndian, ret.EmptySkyLightMask[iPlayToClientPacketUpdateLightEmptySkyLightMask]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.EmptyBlockLightMask))) + if err != nil { + return + } + for iPlayToClientPacketUpdateLightEmptyBlockLightMask := range len(ret.EmptyBlockLightMask) { + err = binary.Write(w, binary.BigEndian, ret.EmptyBlockLightMask[iPlayToClientPacketUpdateLightEmptyBlockLightMask]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight))) + if err != nil { + return + } + for iPlayToClientPacketUpdateLightSkyLight := range len(ret.SkyLight) { + err = proto_base.EncodeVarInt(w, int32(len(ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight]))) + if err != nil { + return + } + for iPlayToClientPacketUpdateLightSkyLightInner := range len(ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight]) { + err = binary.Write(w, binary.BigEndian, ret.SkyLight[iPlayToClientPacketUpdateLightSkyLight][iPlayToClientPacketUpdateLightSkyLightInner]) + if err != nil { + return + } + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight))) + if err != nil { + return + } + for iPlayToClientPacketUpdateLightBlockLight := range len(ret.BlockLight) { + err = proto_base.EncodeVarInt(w, int32(len(ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight]))) + if err != nil { + return + } + for iPlayToClientPacketUpdateLightBlockLightInner := range len(ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight]) { + err = binary.Write(w, binary.BigEndian, ret.BlockLight[iPlayToClientPacketUpdateLightBlockLight][iPlayToClientPacketUpdateLightBlockLightInner]) + if err != nil { + return + } + } + } + return +} + +type PlayToClientPacketUpdateTime struct { + Age int64 + Time int64 + TickDayTime bool +} + +func (ret *PlayToClientPacketUpdateTime) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Age) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Time) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.TickDayTime) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketUpdateTime) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Age) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Time) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.TickDayTime) + if err != nil { + return + } + return +} + +type PlayToClientPacketUpdateViewDistance struct { + ViewDistance int32 +} + +func (ret *PlayToClientPacketUpdateViewDistance) Decode(r io.Reader) (err error) { + ret.ViewDistance, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketUpdateViewDistance) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.ViewDistance) + if err != nil { + return + } + return +} + +type PlayToClientPacketUpdateViewPosition struct { + ChunkX int32 + ChunkZ int32 +} + +func (ret *PlayToClientPacketUpdateViewPosition) Decode(r io.Reader) (err error) { + ret.ChunkX, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ChunkZ, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketUpdateViewPosition) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.ChunkX) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChunkZ) + if err != nil { + return + } + return +} + +type PlayToClientPacketVehicleMove struct { + X float64 + Y float64 + Z float64 + Yaw float32 + Pitch float32 +} + +func (ret *PlayToClientPacketVehicleMove) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketVehicleMove) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + return +} + +type PlayToClientPacketWindowItems struct { + WindowId ContainerID + StateId int32 + Items []Slot + CarriedItem Slot +} + +func (ret *PlayToClientPacketWindowItems) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + ret.StateId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lPlayToClientPacketWindowItemsItems int32 + lPlayToClientPacketWindowItemsItems, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Items = []Slot{} + for range lPlayToClientPacketWindowItemsItems { + var PlayToClientPacketWindowItemsItemsElement Slot + err = PlayToClientPacketWindowItemsItemsElement.Decode(r) + if err != nil { + return + } + ret.Items = append(ret.Items, PlayToClientPacketWindowItemsItemsElement) + } + err = ret.CarriedItem.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketWindowItems) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.StateId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Items))) + if err != nil { + return + } + for iPlayToClientPacketWindowItemsItems := range len(ret.Items) { + err = ret.Items[iPlayToClientPacketWindowItemsItems].Encode(w) + if err != nil { + return + } + } + err = ret.CarriedItem.Encode(w) + if err != nil { + return + } + return +} + +type PlayToClientPacketWorldBorderCenter struct { + X float64 + Z float64 +} + +func (ret *PlayToClientPacketWorldBorderCenter) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketWorldBorderCenter) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + return +} + +type PlayToClientPacketWorldBorderLerpSize struct { + OldDiameter float64 + NewDiameter float64 + Speed int32 +} + +func (ret *PlayToClientPacketWorldBorderLerpSize) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.OldDiameter) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.NewDiameter) + if err != nil { + return + } + ret.Speed, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketWorldBorderLerpSize) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.OldDiameter) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.NewDiameter) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Speed) + if err != nil { + return + } + return +} + +type PlayToClientPacketWorldBorderSize struct { + Diameter float64 +} + +func (ret *PlayToClientPacketWorldBorderSize) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Diameter) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketWorldBorderSize) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Diameter) + if err != nil { + return + } + return +} + +type PlayToClientPacketWorldBorderWarningDelay struct { + WarningTime int32 +} + +func (ret *PlayToClientPacketWorldBorderWarningDelay) Decode(r io.Reader) (err error) { + ret.WarningTime, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketWorldBorderWarningDelay) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.WarningTime) + if err != nil { + return + } + return +} + +type PlayToClientPacketWorldBorderWarningReach struct { + WarningBlocks int32 +} + +func (ret *PlayToClientPacketWorldBorderWarningReach) Decode(r io.Reader) (err error) { + ret.WarningBlocks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketWorldBorderWarningReach) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.WarningBlocks) + if err != nil { + return + } + return +} + +type PlayToClientPacketWorldEvent struct { + EffectId int32 + Location Position + Data int32 + Global bool +} + +func (ret *PlayToClientPacketWorldEvent) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.EffectId) + if err != nil { + return + } + err = ret.Location.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Data) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Global) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketWorldEvent) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.EffectId) + if err != nil { + return + } + err = ret.Location.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Data) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Global) + if err != nil { + return + } + return +} + +type PlayToClientPacketWorldParticles struct { + LongDistance bool + AlwaysShow bool + X float64 + Y float64 + Z float64 + OffsetX float32 + OffsetY float32 + OffsetZ float32 + VelocityOffset float32 + Amount int32 + Particle Particle +} + +func (ret *PlayToClientPacketWorldParticles) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.LongDistance) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.AlwaysShow) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OffsetX) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OffsetY) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OffsetZ) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.VelocityOffset) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Amount) + if err != nil { + return + } + err = ret.Particle.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToClientPacketWorldParticles) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.LongDistance) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.AlwaysShow) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OffsetX) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OffsetY) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OffsetZ) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.VelocityOffset) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Amount) + if err != nil { + return + } + err = ret.Particle.Encode(w) + if err != nil { + return + } + return +} + +type HandshakingToServerPacket struct { + Name string + Params any +} + +var HandshakingToServerPacketNameMap = map[int32]string{0x00: "set_protocol", 0xfe: "legacy_server_list_ping"} + +func (ret *HandshakingToServerPacket) Decode(r io.Reader) (err error) { + var HandshakingToServerPacketNameKey int32 + HandshakingToServerPacketNameKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.ErroringIndex(HandshakingToServerPacketNameMap, HandshakingToServerPacketNameKey) + if err != nil { + return + } + switch ret.Name { + case "legacy_server_list_ping": + var HandshakingToServerPacketParamsLegacyServerListPingTmp HandshakingToServerPacketLegacyServerListPing + err = HandshakingToServerPacketParamsLegacyServerListPingTmp.Decode(r) + if err != nil { + return + } + ret.Params = HandshakingToServerPacketParamsLegacyServerListPingTmp + case "set_protocol": + var HandshakingToServerPacketParamsSetProtocolTmp HandshakingToServerPacketSetProtocol + err = HandshakingToServerPacketParamsSetProtocolTmp.Decode(r) + if err != nil { + return + } + ret.Params = HandshakingToServerPacketParamsSetProtocolTmp + } + return +} + +var HandshakingToServerPacketNameReverseMap = map[string]int32{"set_protocol": 0x00, "legacy_server_list_ping": 0xfe} + +func (ret *HandshakingToServerPacket) Encode(w io.Writer) (err error) { + var vHandshakingToServerPacketName int32 + vHandshakingToServerPacketName, err = proto_base.ErroringIndex(HandshakingToServerPacketNameReverseMap, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vHandshakingToServerPacketName) + if err != nil { + return + } + switch ret.Name { + case "legacy_server_list_ping": + HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketLegacyServerListPing) + if !ok { + err = proto_base.BadTypeError + return + } + err = HandshakingToServerPacketParams.Encode(w) + if err != nil { + return + } + case "set_protocol": + HandshakingToServerPacketParams, ok := ret.Params.(HandshakingToServerPacketSetProtocol) + if !ok { + err = proto_base.BadTypeError + return + } + err = HandshakingToServerPacketParams.Encode(w) + if err != nil { + return + } + } + return +} + +type HandshakingToServerPacketCommonAddResourcePack struct { + Uuid uuid.UUID + Url string + Hash string + Forced bool + PromptMessage *nbt.Anon +} + +func (ret *HandshakingToServerPacketCommonAddResourcePack) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Url, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Hash, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Forced) + if err != nil { + return + } + var HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent bool + err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent) + if err != nil { + return + } + if HandshakingToServerPacketCommonAddResourcePackPromptMessagePresent { + var HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon + err = HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.PromptMessage = &HandshakingToServerPacketCommonAddResourcePackPromptMessagePresentValue + } + return +} +func (ret *HandshakingToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Url) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Hash) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Forced) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) + if err != nil { + return + } + if ret.PromptMessage != nil { + err = (*ret.PromptMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type HandshakingToServerPacketCommonClearDialog struct { +} + +func (ret *HandshakingToServerPacketCommonClearDialog) Decode(r io.Reader) (err error) { + return +} +func (ret *HandshakingToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) { + return +} + +type HandshakingToServerPacketCommonCookieRequest struct { + Cookie string +} + +func (ret *HandshakingToServerPacketCommonCookieRequest) Decode(r io.Reader) (err error) { + ret.Cookie, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *HandshakingToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Cookie) + if err != nil { + return + } + return +} + +type HandshakingToServerPacketCommonCookieResponse struct { + Key string + Value *ByteArray +} + +func (ret *HandshakingToServerPacketCommonCookieResponse) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var HandshakingToServerPacketCommonCookieResponseValuePresent bool + err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonCookieResponseValuePresent) + if err != nil { + return + } + if HandshakingToServerPacketCommonCookieResponseValuePresent { + var HandshakingToServerPacketCommonCookieResponseValuePresentValue ByteArray + err = HandshakingToServerPacketCommonCookieResponseValuePresentValue.Decode(r) + if err != nil { + return + } + ret.Value = &HandshakingToServerPacketCommonCookieResponseValuePresentValue + } + return +} +func (ret *HandshakingToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value != nil) + if err != nil { + return + } + if ret.Value != nil { + err = (*ret.Value).Encode(w) + if err != nil { + return + } + } + return +} + +type HandshakingToServerPacketCommonCustomClickAction struct { + Id string + Nbt *nbt.Anon +} + +func (ret *HandshakingToServerPacketCommonCustomClickAction) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var HandshakingToServerPacketCommonCustomClickActionNbtPresent bool + err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonCustomClickActionNbtPresent) + if err != nil { + return + } + if HandshakingToServerPacketCommonCustomClickActionNbtPresent { + var HandshakingToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon + err = HandshakingToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r) + if err != nil { + return + } + ret.Nbt = &HandshakingToServerPacketCommonCustomClickActionNbtPresentValue + } + return +} +func (ret *HandshakingToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) + if err != nil { + return + } + if ret.Nbt != nil { + err = (*ret.Nbt).Encode(w) + if err != nil { + return + } + } + return +} + +type HandshakingToServerPacketCommonCustomReportDetails struct { + Details []struct { + Key string + Value string + } +} + +func (ret *HandshakingToServerPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) { + var lHandshakingToServerPacketCommonCustomReportDetailsDetails int32 + lHandshakingToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Details = []struct { + Key string + Value string + }{} + for range lHandshakingToServerPacketCommonCustomReportDetailsDetails { + var HandshakingToServerPacketCommonCustomReportDetailsDetailsElement struct { + Key string + Value string + } + HandshakingToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + HandshakingToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Details = append(ret.Details, HandshakingToServerPacketCommonCustomReportDetailsDetailsElement) + } + return +} +func (ret *HandshakingToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) + if err != nil { + return + } + for iHandshakingToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) { + err = proto_base.EncodeString(w, ret.Details[iHandshakingToServerPacketCommonCustomReportDetailsDetails].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Details[iHandshakingToServerPacketCommonCustomReportDetailsDetails].Value) + if err != nil { + return + } + } + return +} + +type HandshakingToServerPacketCommonRemoveResourcePack struct { + Uuid *uuid.UUID +} + +func (ret *HandshakingToServerPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) { + var HandshakingToServerPacketCommonRemoveResourcePackUuidPresent bool + err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonRemoveResourcePackUuidPresent) + if err != nil { + return + } + if HandshakingToServerPacketCommonRemoveResourcePackUuidPresent { + var HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID + _, err = io.ReadFull(r, HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue[:]) + if err != nil { + return + } + ret.Uuid = &HandshakingToServerPacketCommonRemoveResourcePackUuidPresentValue + } + return +} +func (ret *HandshakingToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) + if err != nil { + return + } + if ret.Uuid != nil { + _, err = w.Write((*ret.Uuid)[:]) + if err != nil { + return + } + } + return +} + +type HandshakingToServerPacketCommonSelectKnownPacks struct { + Packs []struct { + Namespace string + Id string + Version string + } +} + +func (ret *HandshakingToServerPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) { + var lHandshakingToServerPacketCommonSelectKnownPacksPacks int32 + lHandshakingToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Packs = []struct { + Namespace string + Id string + Version string + }{} + for range lHandshakingToServerPacketCommonSelectKnownPacksPacks { + var HandshakingToServerPacketCommonSelectKnownPacksPacksElement struct { + Namespace string + Id string + Version string + } + HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) + if err != nil { + return + } + HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + HandshakingToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Packs = append(ret.Packs, HandshakingToServerPacketCommonSelectKnownPacksPacksElement) + } + return +} +func (ret *HandshakingToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) + if err != nil { + return + } + for iHandshakingToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { + err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Namespace) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Id) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iHandshakingToServerPacketCommonSelectKnownPacksPacks].Version) + if err != nil { + return + } + } + return +} + +type HandshakingToServerPacketCommonServerLinks struct { + Links []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } +} + +func (ret *HandshakingToServerPacketCommonServerLinks) Decode(r io.Reader) (err error) { + var lHandshakingToServerPacketCommonServerLinksLinks int32 + lHandshakingToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Links = []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + }{} + for range lHandshakingToServerPacketCommonServerLinksLinks { + var HandshakingToServerPacketCommonServerLinksLinksElement struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } + err = binary.Read(r, binary.BigEndian, &HandshakingToServerPacketCommonServerLinksLinksElement.HasKnownType) + if err != nil { + return + } + switch HandshakingToServerPacketCommonServerLinksLinksElement.HasKnownType { + case true: + var HandshakingToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType + err = HandshakingToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) + if err != nil { + return + } + HandshakingToServerPacketCommonServerLinksLinksElement.KnownType = HandshakingToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp + } + switch HandshakingToServerPacketCommonServerLinksLinksElement.HasKnownType { + case false: + var HandshakingToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon + err = HandshakingToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) + if err != nil { + return + } + HandshakingToServerPacketCommonServerLinksLinksElement.UnknownType = HandshakingToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp + } + HandshakingToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Links = append(ret.Links, HandshakingToServerPacketCommonServerLinksLinksElement) + } + return +} +func (ret *HandshakingToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) + if err != nil { + return + } + for iHandshakingToServerPacketCommonServerLinksLinks := range len(ret.Links) { + err = binary.Write(w, binary.BigEndian, ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].HasKnownType) + if err != nil { + return + } + switch ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].HasKnownType { + case true: + HandshakingToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType) + if !ok { + err = proto_base.BadTypeError + return + } + err = HandshakingToServerPacketCommonServerLinksLinksInnerKnownType.Encode(w) + if err != nil { + return + } + } + switch ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].HasKnownType { + case false: + HandshakingToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = HandshakingToServerPacketCommonServerLinksLinksInnerUnknownType.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Links[iHandshakingToServerPacketCommonServerLinksLinks].Link) + if err != nil { + return + } + } + return +} + +type HandshakingToServerPacketCommonSettings struct { + Locale string + ViewDistance int8 + ChatFlags int32 + ChatColors bool + SkinParts uint8 + MainHand int32 + EnableTextFiltering bool + EnableServerListing bool + ParticleStatus string +} + +var HandshakingToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} + +func (ret *HandshakingToServerPacketCommonSettings) Decode(r io.Reader) (err error) { + ret.Locale, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ViewDistance) + if err != nil { + return + } + ret.ChatFlags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChatColors) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SkinParts) + if err != nil { + return + } + ret.MainHand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) + if err != nil { + return + } + var HandshakingToServerPacketCommonSettingsParticleStatusKey int32 + HandshakingToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ParticleStatus, err = proto_base.ErroringIndex(HandshakingToServerPacketCommonSettingsParticleStatusMap, HandshakingToServerPacketCommonSettingsParticleStatusKey) + if err != nil { + return + } + return +} + +var HandshakingToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} + +func (ret *HandshakingToServerPacketCommonSettings) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Locale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChatFlags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChatColors) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SkinParts) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.MainHand) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) + if err != nil { + return + } + var vHandshakingToServerPacketCommonSettingsParticleStatus int32 + vHandshakingToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(HandshakingToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vHandshakingToServerPacketCommonSettingsParticleStatus) + if err != nil { + return + } + return +} + +type HandshakingToServerPacketCommonStoreCookie struct { + Key string + Value ByteArray +} + +func (ret *HandshakingToServerPacketCommonStoreCookie) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Value.Decode(r) + if err != nil { + return + } + return +} +func (ret *HandshakingToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = ret.Value.Encode(w) + if err != nil { + return + } + return +} + +type HandshakingToServerPacketCommonTransfer struct { + Host string + Port int32 +} + +func (ret *HandshakingToServerPacketCommonTransfer) Decode(r io.Reader) (err error) { + ret.Host, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Port, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *HandshakingToServerPacketCommonTransfer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Host) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Port) + if err != nil { + return + } + return +} + +type HandshakingToServerPacketLegacyServerListPing struct { + Payload uint8 +} + +func (ret *HandshakingToServerPacketLegacyServerListPing) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Payload) + if err != nil { + return + } + return +} +func (ret *HandshakingToServerPacketLegacyServerListPing) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Payload) + if err != nil { + return + } + return +} + +type HandshakingToServerPacketSetProtocol struct { + ProtocolVersion int32 + ServerHost string + ServerPort uint16 + NextState int32 +} + +func (ret *HandshakingToServerPacketSetProtocol) Decode(r io.Reader) (err error) { + ret.ProtocolVersion, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ServerHost, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ServerPort) + if err != nil { + return + } + ret.NextState, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *HandshakingToServerPacketSetProtocol) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.ProtocolVersion) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.ServerHost) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ServerPort) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.NextState) + if err != nil { + return + } + return +} + +type HandshakingToClientPacket struct { + Name string + Params any +} + +var HandshakingToClientPacketNameMap = map[int32]string{} + +func (ret *HandshakingToClientPacket) Decode(r io.Reader) (err error) { + var HandshakingToClientPacketNameKey int32 + HandshakingToClientPacketNameKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.ErroringIndex(HandshakingToClientPacketNameMap, HandshakingToClientPacketNameKey) + if err != nil { + return + } + return +} + +var HandshakingToClientPacketNameReverseMap = map[string]int32{} + +func (ret *HandshakingToClientPacket) Encode(w io.Writer) (err error) { + var vHandshakingToClientPacketName int32 + vHandshakingToClientPacketName, err = proto_base.ErroringIndex(HandshakingToClientPacketNameReverseMap, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vHandshakingToClientPacketName) + if err != nil { + return + } + return +} + +type HandshakingToClientPacketCommonAddResourcePack struct { + Uuid uuid.UUID + Url string + Hash string + Forced bool + PromptMessage *nbt.Anon +} + +func (ret *HandshakingToClientPacketCommonAddResourcePack) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Url, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Hash, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Forced) + if err != nil { + return + } + var HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent bool + err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent) + if err != nil { + return + } + if HandshakingToClientPacketCommonAddResourcePackPromptMessagePresent { + var HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon + err = HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.PromptMessage = &HandshakingToClientPacketCommonAddResourcePackPromptMessagePresentValue + } + return +} +func (ret *HandshakingToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Url) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Hash) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Forced) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) + if err != nil { + return + } + if ret.PromptMessage != nil { + err = (*ret.PromptMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type HandshakingToClientPacketCommonClearDialog struct { +} + +func (ret *HandshakingToClientPacketCommonClearDialog) Decode(r io.Reader) (err error) { + return +} +func (ret *HandshakingToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) { + return +} + +type HandshakingToClientPacketCommonCookieRequest struct { + Cookie string +} + +func (ret *HandshakingToClientPacketCommonCookieRequest) Decode(r io.Reader) (err error) { + ret.Cookie, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *HandshakingToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Cookie) + if err != nil { + return + } + return +} + +type HandshakingToClientPacketCommonCookieResponse struct { + Key string + Value *ByteArray +} + +func (ret *HandshakingToClientPacketCommonCookieResponse) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var HandshakingToClientPacketCommonCookieResponseValuePresent bool + err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonCookieResponseValuePresent) + if err != nil { + return + } + if HandshakingToClientPacketCommonCookieResponseValuePresent { + var HandshakingToClientPacketCommonCookieResponseValuePresentValue ByteArray + err = HandshakingToClientPacketCommonCookieResponseValuePresentValue.Decode(r) + if err != nil { + return + } + ret.Value = &HandshakingToClientPacketCommonCookieResponseValuePresentValue + } + return +} +func (ret *HandshakingToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value != nil) + if err != nil { + return + } + if ret.Value != nil { + err = (*ret.Value).Encode(w) + if err != nil { + return + } + } + return +} + +type HandshakingToClientPacketCommonCustomClickAction struct { + Id string + Nbt *nbt.Anon +} + +func (ret *HandshakingToClientPacketCommonCustomClickAction) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var HandshakingToClientPacketCommonCustomClickActionNbtPresent bool + err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonCustomClickActionNbtPresent) + if err != nil { + return + } + if HandshakingToClientPacketCommonCustomClickActionNbtPresent { + var HandshakingToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon + err = HandshakingToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r) + if err != nil { + return + } + ret.Nbt = &HandshakingToClientPacketCommonCustomClickActionNbtPresentValue + } + return +} +func (ret *HandshakingToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) + if err != nil { + return + } + if ret.Nbt != nil { + err = (*ret.Nbt).Encode(w) + if err != nil { + return + } + } + return +} + +type HandshakingToClientPacketCommonCustomReportDetails struct { + Details []struct { + Key string + Value string + } +} + +func (ret *HandshakingToClientPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) { + var lHandshakingToClientPacketCommonCustomReportDetailsDetails int32 + lHandshakingToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Details = []struct { + Key string + Value string + }{} + for range lHandshakingToClientPacketCommonCustomReportDetailsDetails { + var HandshakingToClientPacketCommonCustomReportDetailsDetailsElement struct { + Key string + Value string + } + HandshakingToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + HandshakingToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Details = append(ret.Details, HandshakingToClientPacketCommonCustomReportDetailsDetailsElement) + } + return +} +func (ret *HandshakingToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) + if err != nil { + return + } + for iHandshakingToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) { + err = proto_base.EncodeString(w, ret.Details[iHandshakingToClientPacketCommonCustomReportDetailsDetails].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Details[iHandshakingToClientPacketCommonCustomReportDetailsDetails].Value) + if err != nil { + return + } + } + return +} + +type HandshakingToClientPacketCommonRemoveResourcePack struct { + Uuid *uuid.UUID +} + +func (ret *HandshakingToClientPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) { + var HandshakingToClientPacketCommonRemoveResourcePackUuidPresent bool + err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonRemoveResourcePackUuidPresent) + if err != nil { + return + } + if HandshakingToClientPacketCommonRemoveResourcePackUuidPresent { + var HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID + _, err = io.ReadFull(r, HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue[:]) + if err != nil { + return + } + ret.Uuid = &HandshakingToClientPacketCommonRemoveResourcePackUuidPresentValue + } + return +} +func (ret *HandshakingToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) + if err != nil { + return + } + if ret.Uuid != nil { + _, err = w.Write((*ret.Uuid)[:]) + if err != nil { + return + } + } + return +} + +type HandshakingToClientPacketCommonSelectKnownPacks struct { + Packs []struct { + Namespace string + Id string + Version string + } +} + +func (ret *HandshakingToClientPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) { + var lHandshakingToClientPacketCommonSelectKnownPacksPacks int32 + lHandshakingToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Packs = []struct { + Namespace string + Id string + Version string + }{} + for range lHandshakingToClientPacketCommonSelectKnownPacksPacks { + var HandshakingToClientPacketCommonSelectKnownPacksPacksElement struct { + Namespace string + Id string + Version string + } + HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) + if err != nil { + return + } + HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + HandshakingToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Packs = append(ret.Packs, HandshakingToClientPacketCommonSelectKnownPacksPacksElement) + } + return +} +func (ret *HandshakingToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) + if err != nil { + return + } + for iHandshakingToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { + err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Namespace) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Id) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iHandshakingToClientPacketCommonSelectKnownPacksPacks].Version) + if err != nil { + return + } + } + return +} + +type HandshakingToClientPacketCommonServerLinks struct { + Links []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } +} + +func (ret *HandshakingToClientPacketCommonServerLinks) Decode(r io.Reader) (err error) { + var lHandshakingToClientPacketCommonServerLinksLinks int32 + lHandshakingToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Links = []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + }{} + for range lHandshakingToClientPacketCommonServerLinksLinks { + var HandshakingToClientPacketCommonServerLinksLinksElement struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } + err = binary.Read(r, binary.BigEndian, &HandshakingToClientPacketCommonServerLinksLinksElement.HasKnownType) + if err != nil { + return + } + switch HandshakingToClientPacketCommonServerLinksLinksElement.HasKnownType { + case true: + var HandshakingToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType + err = HandshakingToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) + if err != nil { + return + } + HandshakingToClientPacketCommonServerLinksLinksElement.KnownType = HandshakingToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp + } + switch HandshakingToClientPacketCommonServerLinksLinksElement.HasKnownType { + case false: + var HandshakingToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon + err = HandshakingToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) + if err != nil { + return + } + HandshakingToClientPacketCommonServerLinksLinksElement.UnknownType = HandshakingToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp + } + HandshakingToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Links = append(ret.Links, HandshakingToClientPacketCommonServerLinksLinksElement) + } + return +} +func (ret *HandshakingToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) + if err != nil { + return + } + for iHandshakingToClientPacketCommonServerLinksLinks := range len(ret.Links) { + err = binary.Write(w, binary.BigEndian, ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].HasKnownType) + if err != nil { + return + } + switch ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].HasKnownType { + case true: + HandshakingToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType) + if !ok { + err = proto_base.BadTypeError + return + } + err = HandshakingToClientPacketCommonServerLinksLinksInnerKnownType.Encode(w) + if err != nil { + return + } + } + switch ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].HasKnownType { + case false: + HandshakingToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = HandshakingToClientPacketCommonServerLinksLinksInnerUnknownType.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Links[iHandshakingToClientPacketCommonServerLinksLinks].Link) + if err != nil { + return + } + } + return +} + +type HandshakingToClientPacketCommonSettings struct { + Locale string + ViewDistance int8 + ChatFlags int32 + ChatColors bool + SkinParts uint8 + MainHand int32 + EnableTextFiltering bool + EnableServerListing bool + ParticleStatus string +} + +var HandshakingToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} + +func (ret *HandshakingToClientPacketCommonSettings) Decode(r io.Reader) (err error) { + ret.Locale, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ViewDistance) + if err != nil { + return + } + ret.ChatFlags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChatColors) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SkinParts) + if err != nil { + return + } + ret.MainHand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) + if err != nil { + return + } + var HandshakingToClientPacketCommonSettingsParticleStatusKey int32 + HandshakingToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ParticleStatus, err = proto_base.ErroringIndex(HandshakingToClientPacketCommonSettingsParticleStatusMap, HandshakingToClientPacketCommonSettingsParticleStatusKey) + if err != nil { + return + } + return +} + +var HandshakingToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} + +func (ret *HandshakingToClientPacketCommonSettings) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Locale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChatFlags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChatColors) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SkinParts) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.MainHand) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) + if err != nil { + return + } + var vHandshakingToClientPacketCommonSettingsParticleStatus int32 + vHandshakingToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(HandshakingToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vHandshakingToClientPacketCommonSettingsParticleStatus) + if err != nil { + return + } + return +} + +type HandshakingToClientPacketCommonStoreCookie struct { + Key string + Value ByteArray +} + +func (ret *HandshakingToClientPacketCommonStoreCookie) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Value.Decode(r) + if err != nil { + return + } + return +} +func (ret *HandshakingToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = ret.Value.Encode(w) + if err != nil { + return + } + return +} + +type HandshakingToClientPacketCommonTransfer struct { + Host string + Port int32 +} + +func (ret *HandshakingToClientPacketCommonTransfer) Decode(r io.Reader) (err error) { + ret.Host, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Port, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *HandshakingToClientPacketCommonTransfer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Host) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Port) + if err != nil { + return + } + return +} + +type PlayToServerMovementFlags struct { + Val uint8 +} + +func (ret *PlayToServerMovementFlags) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Val) + if err != nil { + return + } + return +} +func (ret *PlayToServerMovementFlags) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Val) + if err != nil { + return + } + return +} + +type PlayToServerPacket struct { + Name string + Params any +} + +var PlayToServerPacketNameMap = map[int32]string{0x00: "teleport_confirm", 0x01: "query_block_nbt", 0x02: "select_bundle_item", 0x03: "set_difficulty", 0x04: "change_gamemode", 0x05: "message_acknowledgement", 0x06: "chat_command", 0x07: "chat_command_signed", 0x08: "chat_message", 0x09: "chat_session_update", 0x0a: "chunk_batch_received", 0x0b: "client_command", 0x0c: "tick_end", 0x0d: "settings", 0x0e: "tab_complete", 0x0f: "configuration_acknowledged", 0x10: "enchant_item", 0x11: "window_click", 0x12: "close_window", 0x13: "set_slot_state", 0x14: "cookie_response", 0x15: "custom_payload", 0x16: "debug_sample_subscription", 0x17: "edit_book", 0x18: "query_entity_nbt", 0x19: "use_entity", 0x1a: "generate_structure", 0x1b: "keep_alive", 0x1c: "lock_difficulty", 0x1d: "position", 0x1e: "position_look", 0x1f: "look", 0x20: "flying", 0x21: "vehicle_move", 0x22: "steer_boat", 0x23: "pick_item_from_block", 0x24: "pick_item_from_entity", 0x25: "ping_request", 0x26: "craft_recipe_request", 0x27: "abilities", 0x28: "block_dig", 0x29: "entity_action", 0x2a: "player_input", 0x2b: "player_loaded", 0x2c: "pong", 0x2d: "recipe_book", 0x2e: "displayed_recipe", 0x2f: "name_item", 0x30: "resource_pack_receive", 0x31: "advancement_tab", 0x32: "select_trade", 0x33: "set_beacon_effect", 0x34: "held_item_slot", 0x35: "update_command_block", 0x36: "update_command_block_minecart", 0x37: "set_creative_slot", 0x38: "update_jigsaw_block", 0x39: "update_structure_block", 0x3a: "set_test_block", 0x3b: "update_sign", 0x3c: "arm_animation", 0x3d: "spectate", 0x3e: "test_instance_block_action", 0x3f: "block_place", 0x40: "use_item", 0x41: "custom_click_action"} + +func (ret *PlayToServerPacket) Decode(r io.Reader) (err error) { + var PlayToServerPacketNameKey int32 + PlayToServerPacketNameKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.ErroringIndex(PlayToServerPacketNameMap, PlayToServerPacketNameKey) + if err != nil { + return + } + switch ret.Name { + case "abilities": + var PlayToServerPacketParamsAbilitiesTmp PlayToServerPacketAbilities + err = PlayToServerPacketParamsAbilitiesTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsAbilitiesTmp + case "advancement_tab": + var PlayToServerPacketParamsAdvancementTabTmp PlayToServerPacketAdvancementTab + err = PlayToServerPacketParamsAdvancementTabTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsAdvancementTabTmp + case "arm_animation": + var PlayToServerPacketParamsArmAnimationTmp PlayToServerPacketArmAnimation + err = PlayToServerPacketParamsArmAnimationTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsArmAnimationTmp + case "block_dig": + var PlayToServerPacketParamsBlockDigTmp PlayToServerPacketBlockDig + err = PlayToServerPacketParamsBlockDigTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsBlockDigTmp + case "block_place": + var PlayToServerPacketParamsBlockPlaceTmp PlayToServerPacketBlockPlace + err = PlayToServerPacketParamsBlockPlaceTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsBlockPlaceTmp + case "change_gamemode": + var PlayToServerPacketParamsChangeGamemodeTmp PlayToServerPacketChangeGamemode + err = PlayToServerPacketParamsChangeGamemodeTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsChangeGamemodeTmp + case "chat_command": + var PlayToServerPacketParamsChatCommandTmp PlayToServerPacketChatCommand + err = PlayToServerPacketParamsChatCommandTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsChatCommandTmp + case "chat_command_signed": + var PlayToServerPacketParamsChatCommandSignedTmp PlayToServerPacketChatCommandSigned + err = PlayToServerPacketParamsChatCommandSignedTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsChatCommandSignedTmp + case "chat_message": + var PlayToServerPacketParamsChatMessageTmp PlayToServerPacketChatMessage + err = PlayToServerPacketParamsChatMessageTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsChatMessageTmp + case "chat_session_update": + var PlayToServerPacketParamsChatSessionUpdateTmp PlayToServerPacketChatSessionUpdate + err = PlayToServerPacketParamsChatSessionUpdateTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsChatSessionUpdateTmp + case "chunk_batch_received": + var PlayToServerPacketParamsChunkBatchReceivedTmp PlayToServerPacketChunkBatchReceived + err = PlayToServerPacketParamsChunkBatchReceivedTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsChunkBatchReceivedTmp + case "client_command": + var PlayToServerPacketParamsClientCommandTmp PlayToServerPacketClientCommand + err = PlayToServerPacketParamsClientCommandTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsClientCommandTmp + case "close_window": + var PlayToServerPacketParamsCloseWindowTmp PlayToServerPacketCloseWindow + err = PlayToServerPacketParamsCloseWindowTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsCloseWindowTmp + case "configuration_acknowledged": + var PlayToServerPacketParamsConfigurationAcknowledgedTmp PlayToServerPacketConfigurationAcknowledged + err = PlayToServerPacketParamsConfigurationAcknowledgedTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsConfigurationAcknowledgedTmp + case "cookie_response": + var PlayToServerPacketParamsCookieResponseTmp PlayToServerPacketCommonCookieResponse + err = PlayToServerPacketParamsCookieResponseTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsCookieResponseTmp + case "craft_recipe_request": + var PlayToServerPacketParamsCraftRecipeRequestTmp PlayToServerPacketCraftRecipeRequest + err = PlayToServerPacketParamsCraftRecipeRequestTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsCraftRecipeRequestTmp + case "custom_click_action": + var PlayToServerPacketParamsCustomClickActionTmp PlayToServerPacketCommonCustomClickAction + err = PlayToServerPacketParamsCustomClickActionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsCustomClickActionTmp + case "custom_payload": + var PlayToServerPacketParamsCustomPayloadTmp PlayToServerPacketCustomPayload + err = PlayToServerPacketParamsCustomPayloadTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsCustomPayloadTmp + case "debug_sample_subscription": + var PlayToServerPacketParamsDebugSampleSubscriptionTmp PlayToServerPacketDebugSampleSubscription + err = PlayToServerPacketParamsDebugSampleSubscriptionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsDebugSampleSubscriptionTmp + case "displayed_recipe": + var PlayToServerPacketParamsDisplayedRecipeTmp PlayToServerPacketDisplayedRecipe + err = PlayToServerPacketParamsDisplayedRecipeTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsDisplayedRecipeTmp + case "edit_book": + var PlayToServerPacketParamsEditBookTmp PlayToServerPacketEditBook + err = PlayToServerPacketParamsEditBookTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsEditBookTmp + case "enchant_item": + var PlayToServerPacketParamsEnchantItemTmp PlayToServerPacketEnchantItem + err = PlayToServerPacketParamsEnchantItemTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsEnchantItemTmp + case "entity_action": + var PlayToServerPacketParamsEntityActionTmp PlayToServerPacketEntityAction + err = PlayToServerPacketParamsEntityActionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsEntityActionTmp + case "flying": + var PlayToServerPacketParamsFlyingTmp PlayToServerPacketFlying + err = PlayToServerPacketParamsFlyingTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsFlyingTmp + case "generate_structure": + var PlayToServerPacketParamsGenerateStructureTmp PlayToServerPacketGenerateStructure + err = PlayToServerPacketParamsGenerateStructureTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsGenerateStructureTmp + case "held_item_slot": + var PlayToServerPacketParamsHeldItemSlotTmp PlayToServerPacketHeldItemSlot + err = PlayToServerPacketParamsHeldItemSlotTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsHeldItemSlotTmp + case "keep_alive": + var PlayToServerPacketParamsKeepAliveTmp PlayToServerPacketKeepAlive + err = PlayToServerPacketParamsKeepAliveTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsKeepAliveTmp + case "lock_difficulty": + var PlayToServerPacketParamsLockDifficultyTmp PlayToServerPacketLockDifficulty + err = PlayToServerPacketParamsLockDifficultyTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsLockDifficultyTmp + case "look": + var PlayToServerPacketParamsLookTmp PlayToServerPacketLook + err = PlayToServerPacketParamsLookTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsLookTmp + case "message_acknowledgement": + var PlayToServerPacketParamsMessageAcknowledgementTmp PlayToServerPacketMessageAcknowledgement + err = PlayToServerPacketParamsMessageAcknowledgementTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsMessageAcknowledgementTmp + case "name_item": + var PlayToServerPacketParamsNameItemTmp PlayToServerPacketNameItem + err = PlayToServerPacketParamsNameItemTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsNameItemTmp + case "pick_item_from_block": + var PlayToServerPacketParamsPickItemFromBlockTmp PlayToServerPacketPickItemFromBlock + err = PlayToServerPacketParamsPickItemFromBlockTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsPickItemFromBlockTmp + case "pick_item_from_entity": + var PlayToServerPacketParamsPickItemFromEntityTmp PlayToServerPacketPickItemFromEntity + err = PlayToServerPacketParamsPickItemFromEntityTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsPickItemFromEntityTmp + case "ping_request": + var PlayToServerPacketParamsPingRequestTmp PlayToServerPacketPingRequest + err = PlayToServerPacketParamsPingRequestTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsPingRequestTmp + case "player_input": + var PlayToServerPacketParamsPlayerInputTmp PlayToServerPacketPlayerInput + err = PlayToServerPacketParamsPlayerInputTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsPlayerInputTmp + case "player_loaded": + var PlayToServerPacketParamsPlayerLoadedTmp PlayToServerPacketPlayerLoaded + err = PlayToServerPacketParamsPlayerLoadedTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsPlayerLoadedTmp + case "pong": + var PlayToServerPacketParamsPongTmp PlayToServerPacketPong + err = PlayToServerPacketParamsPongTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsPongTmp + case "position": + var PlayToServerPacketParamsPositionTmp PlayToServerPacketPosition + err = PlayToServerPacketParamsPositionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsPositionTmp + case "position_look": + var PlayToServerPacketParamsPositionLookTmp PlayToServerPacketPositionLook + err = PlayToServerPacketParamsPositionLookTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsPositionLookTmp + case "query_block_nbt": + var PlayToServerPacketParamsQueryBlockNbtTmp PlayToServerPacketQueryBlockNbt + err = PlayToServerPacketParamsQueryBlockNbtTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsQueryBlockNbtTmp + case "query_entity_nbt": + var PlayToServerPacketParamsQueryEntityNbtTmp PlayToServerPacketQueryEntityNbt + err = PlayToServerPacketParamsQueryEntityNbtTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsQueryEntityNbtTmp + case "recipe_book": + var PlayToServerPacketParamsRecipeBookTmp PlayToServerPacketRecipeBook + err = PlayToServerPacketParamsRecipeBookTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsRecipeBookTmp + case "resource_pack_receive": + var PlayToServerPacketParamsResourcePackReceiveTmp PlayToServerPacketResourcePackReceive + err = PlayToServerPacketParamsResourcePackReceiveTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsResourcePackReceiveTmp + case "select_bundle_item": + var PlayToServerPacketParamsSelectBundleItemTmp PlayToServerPacketSelectBundleItem + err = PlayToServerPacketParamsSelectBundleItemTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsSelectBundleItemTmp + case "select_trade": + var PlayToServerPacketParamsSelectTradeTmp PlayToServerPacketSelectTrade + err = PlayToServerPacketParamsSelectTradeTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsSelectTradeTmp + case "set_beacon_effect": + var PlayToServerPacketParamsSetBeaconEffectTmp PlayToServerPacketSetBeaconEffect + err = PlayToServerPacketParamsSetBeaconEffectTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsSetBeaconEffectTmp + case "set_creative_slot": + var PlayToServerPacketParamsSetCreativeSlotTmp PlayToServerPacketSetCreativeSlot + err = PlayToServerPacketParamsSetCreativeSlotTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsSetCreativeSlotTmp + case "set_difficulty": + var PlayToServerPacketParamsSetDifficultyTmp PlayToServerPacketSetDifficulty + err = PlayToServerPacketParamsSetDifficultyTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsSetDifficultyTmp + case "set_slot_state": + var PlayToServerPacketParamsSetSlotStateTmp PlayToServerPacketSetSlotState + err = PlayToServerPacketParamsSetSlotStateTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsSetSlotStateTmp + case "set_test_block": + var PlayToServerPacketParamsSetTestBlockTmp PlayToServerPacketSetTestBlock + err = PlayToServerPacketParamsSetTestBlockTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsSetTestBlockTmp + case "settings": + var PlayToServerPacketParamsSettingsTmp PlayToServerPacketCommonSettings + err = PlayToServerPacketParamsSettingsTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsSettingsTmp + case "spectate": + var PlayToServerPacketParamsSpectateTmp PlayToServerPacketSpectate + err = PlayToServerPacketParamsSpectateTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsSpectateTmp + case "steer_boat": + var PlayToServerPacketParamsSteerBoatTmp PlayToServerPacketSteerBoat + err = PlayToServerPacketParamsSteerBoatTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsSteerBoatTmp + case "tab_complete": + var PlayToServerPacketParamsTabCompleteTmp PlayToServerPacketTabComplete + err = PlayToServerPacketParamsTabCompleteTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsTabCompleteTmp + case "teleport_confirm": + var PlayToServerPacketParamsTeleportConfirmTmp PlayToServerPacketTeleportConfirm + err = PlayToServerPacketParamsTeleportConfirmTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsTeleportConfirmTmp + case "test_instance_block_action": + var PlayToServerPacketParamsTestInstanceBlockActionTmp PlayToServerPacketTestInstanceBlockAction + err = PlayToServerPacketParamsTestInstanceBlockActionTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsTestInstanceBlockActionTmp + case "tick_end": + var PlayToServerPacketParamsTickEndTmp PlayToServerPacketTickEnd + err = PlayToServerPacketParamsTickEndTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsTickEndTmp + case "update_command_block": + var PlayToServerPacketParamsUpdateCommandBlockTmp PlayToServerPacketUpdateCommandBlock + err = PlayToServerPacketParamsUpdateCommandBlockTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsUpdateCommandBlockTmp + case "update_command_block_minecart": + var PlayToServerPacketParamsUpdateCommandBlockMinecartTmp PlayToServerPacketUpdateCommandBlockMinecart + err = PlayToServerPacketParamsUpdateCommandBlockMinecartTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsUpdateCommandBlockMinecartTmp + case "update_jigsaw_block": + var PlayToServerPacketParamsUpdateJigsawBlockTmp PlayToServerPacketUpdateJigsawBlock + err = PlayToServerPacketParamsUpdateJigsawBlockTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsUpdateJigsawBlockTmp + case "update_sign": + var PlayToServerPacketParamsUpdateSignTmp PlayToServerPacketUpdateSign + err = PlayToServerPacketParamsUpdateSignTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsUpdateSignTmp + case "update_structure_block": + var PlayToServerPacketParamsUpdateStructureBlockTmp PlayToServerPacketUpdateStructureBlock + err = PlayToServerPacketParamsUpdateStructureBlockTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsUpdateStructureBlockTmp + case "use_entity": + var PlayToServerPacketParamsUseEntityTmp PlayToServerPacketUseEntity + err = PlayToServerPacketParamsUseEntityTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsUseEntityTmp + case "use_item": + var PlayToServerPacketParamsUseItemTmp PlayToServerPacketUseItem + err = PlayToServerPacketParamsUseItemTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsUseItemTmp + case "vehicle_move": + var PlayToServerPacketParamsVehicleMoveTmp PlayToServerPacketVehicleMove + err = PlayToServerPacketParamsVehicleMoveTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsVehicleMoveTmp + case "window_click": + var PlayToServerPacketParamsWindowClickTmp PlayToServerPacketWindowClick + err = PlayToServerPacketParamsWindowClickTmp.Decode(r) + if err != nil { + return + } + ret.Params = PlayToServerPacketParamsWindowClickTmp + } + return +} + +var PlayToServerPacketNameReverseMap = map[string]int32{"teleport_confirm": 0x00, "query_block_nbt": 0x01, "select_bundle_item": 0x02, "set_difficulty": 0x03, "change_gamemode": 0x04, "message_acknowledgement": 0x05, "chat_command": 0x06, "chat_command_signed": 0x07, "chat_message": 0x08, "chat_session_update": 0x09, "chunk_batch_received": 0x0a, "client_command": 0x0b, "tick_end": 0x0c, "settings": 0x0d, "tab_complete": 0x0e, "configuration_acknowledged": 0x0f, "enchant_item": 0x10, "window_click": 0x11, "close_window": 0x12, "set_slot_state": 0x13, "cookie_response": 0x14, "custom_payload": 0x15, "debug_sample_subscription": 0x16, "edit_book": 0x17, "query_entity_nbt": 0x18, "use_entity": 0x19, "generate_structure": 0x1a, "keep_alive": 0x1b, "lock_difficulty": 0x1c, "position": 0x1d, "position_look": 0x1e, "look": 0x1f, "flying": 0x20, "vehicle_move": 0x21, "steer_boat": 0x22, "pick_item_from_block": 0x23, "pick_item_from_entity": 0x24, "ping_request": 0x25, "craft_recipe_request": 0x26, "abilities": 0x27, "block_dig": 0x28, "entity_action": 0x29, "player_input": 0x2a, "player_loaded": 0x2b, "pong": 0x2c, "recipe_book": 0x2d, "displayed_recipe": 0x2e, "name_item": 0x2f, "resource_pack_receive": 0x30, "advancement_tab": 0x31, "select_trade": 0x32, "set_beacon_effect": 0x33, "held_item_slot": 0x34, "update_command_block": 0x35, "update_command_block_minecart": 0x36, "set_creative_slot": 0x37, "update_jigsaw_block": 0x38, "update_structure_block": 0x39, "set_test_block": 0x3a, "update_sign": 0x3b, "arm_animation": 0x3c, "spectate": 0x3d, "test_instance_block_action": 0x3e, "block_place": 0x3f, "use_item": 0x40, "custom_click_action": 0x41} + +func (ret *PlayToServerPacket) Encode(w io.Writer) (err error) { + var vPlayToServerPacketName int32 + vPlayToServerPacketName, err = proto_base.ErroringIndex(PlayToServerPacketNameReverseMap, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToServerPacketName) + if err != nil { + return + } + switch ret.Name { + case "abilities": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAbilities) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "advancement_tab": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketAdvancementTab) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "arm_animation": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketArmAnimation) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "block_dig": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockDig) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "block_place": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketBlockPlace) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "change_gamemode": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChangeGamemode) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "chat_command": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatCommand) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "chat_command_signed": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatCommandSigned) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "chat_message": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatMessage) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "chat_session_update": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChatSessionUpdate) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "chunk_batch_received": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketChunkBatchReceived) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "client_command": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketClientCommand) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "close_window": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCloseWindow) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "configuration_acknowledged": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketConfigurationAcknowledged) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "cookie_response": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonCookieResponse) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "craft_recipe_request": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCraftRecipeRequest) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "custom_click_action": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonCustomClickAction) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "custom_payload": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCustomPayload) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "debug_sample_subscription": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketDebugSampleSubscription) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "displayed_recipe": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketDisplayedRecipe) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "edit_book": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEditBook) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "enchant_item": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEnchantItem) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "entity_action": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketEntityAction) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "flying": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketFlying) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "generate_structure": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketGenerateStructure) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "held_item_slot": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketHeldItemSlot) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "keep_alive": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketKeepAlive) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "lock_difficulty": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLockDifficulty) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "look": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketLook) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "message_acknowledgement": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketMessageAcknowledgement) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "name_item": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketNameItem) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "pick_item_from_block": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItemFromBlock) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "pick_item_from_entity": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPickItemFromEntity) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "ping_request": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPingRequest) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "player_input": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPlayerInput) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "player_loaded": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPlayerLoaded) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "pong": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPong) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "position": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPosition) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "position_look": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketPositionLook) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "query_block_nbt": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryBlockNbt) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "query_entity_nbt": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketQueryEntityNbt) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "recipe_book": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketRecipeBook) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "resource_pack_receive": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketResourcePackReceive) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "select_bundle_item": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSelectBundleItem) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "select_trade": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSelectTrade) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "set_beacon_effect": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetBeaconEffect) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "set_creative_slot": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetCreativeSlot) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "set_difficulty": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetDifficulty) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "set_slot_state": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetSlotState) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "set_test_block": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSetTestBlock) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "settings": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketCommonSettings) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "spectate": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSpectate) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "steer_boat": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketSteerBoat) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "tab_complete": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTabComplete) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "teleport_confirm": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTeleportConfirm) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "test_instance_block_action": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTestInstanceBlockAction) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "tick_end": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketTickEnd) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "update_command_block": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlock) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "update_command_block_minecart": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateCommandBlockMinecart) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "update_jigsaw_block": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateJigsawBlock) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "update_sign": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateSign) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "update_structure_block": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUpdateStructureBlock) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "use_entity": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseEntity) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "use_item": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketUseItem) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "vehicle_move": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketVehicleMove) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + case "window_click": + PlayToServerPacketParams, ok := ret.Params.(PlayToServerPacketWindowClick) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketParams.Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketAbilities struct { + Flags int8 +} + +func (ret *PlayToServerPacketAbilities) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Flags) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketAbilities) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Flags) + if err != nil { + return + } + return +} + +type PlayToServerPacketAdvancementTab struct { + Action int32 + TabId any +} + +func (ret *PlayToServerPacketAdvancementTab) Decode(r io.Reader) (err error) { + ret.Action, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + switch ret.Action { + case 0: + var PlayToServerPacketAdvancementTabTabId0Tmp string + PlayToServerPacketAdvancementTabTabId0Tmp, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.TabId = PlayToServerPacketAdvancementTabTabId0Tmp + case 1: + var PlayToServerPacketAdvancementTabTabId1Tmp struct { + } + ret.TabId = PlayToServerPacketAdvancementTabTabId1Tmp + } + return +} +func (ret *PlayToServerPacketAdvancementTab) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Action) + if err != nil { + return + } + switch ret.Action { + case 0: + PlayToServerPacketAdvancementTabTabId, ok := ret.TabId.(string) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, PlayToServerPacketAdvancementTabTabId) + if err != nil { + return + } + case 1: + _, ok := ret.TabId.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + return +} + +type PlayToServerPacketArmAnimation struct { + Hand int32 +} + +func (ret *PlayToServerPacketArmAnimation) Decode(r io.Reader) (err error) { + ret.Hand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketArmAnimation) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Hand) + if err != nil { + return + } + return +} + +type PlayToServerPacketBlockDig struct { + Status int32 + Location Position + Face int8 + Sequence int32 +} + +func (ret *PlayToServerPacketBlockDig) Decode(r io.Reader) (err error) { + ret.Status, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.Location.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Face) + if err != nil { + return + } + ret.Sequence, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketBlockDig) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Status) + if err != nil { + return + } + err = ret.Location.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Face) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Sequence) + if err != nil { + return + } + return +} + +type PlayToServerPacketBlockPlace struct { + Hand int32 + Location Position + Direction int32 + CursorX float32 + CursorY float32 + CursorZ float32 + InsideBlock bool + WorldBorderHit bool + Sequence int32 +} + +func (ret *PlayToServerPacketBlockPlace) Decode(r io.Reader) (err error) { + ret.Hand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.Location.Decode(r) + if err != nil { + return + } + ret.Direction, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.CursorX) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.CursorY) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.CursorZ) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.InsideBlock) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.WorldBorderHit) + if err != nil { + return + } + ret.Sequence, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketBlockPlace) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Hand) + if err != nil { + return + } + err = ret.Location.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Direction) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.CursorX) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.CursorY) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.CursorZ) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.InsideBlock) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.WorldBorderHit) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Sequence) + if err != nil { + return + } + return +} + +type PlayToServerPacketChangeGamemode struct { + Mode string +} + +var PlayToServerPacketChangeGamemodeModeMap = map[int32]string{0: "survival", 1: "creative", 2: "adventure", 3: "spectator"} + +func (ret *PlayToServerPacketChangeGamemode) Decode(r io.Reader) (err error) { + var PlayToServerPacketChangeGamemodeModeKey int32 + PlayToServerPacketChangeGamemodeModeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Mode, err = proto_base.ErroringIndex(PlayToServerPacketChangeGamemodeModeMap, PlayToServerPacketChangeGamemodeModeKey) + if err != nil { + return + } + return +} + +var PlayToServerPacketChangeGamemodeModeReverseMap = map[string]int32{"survival": 0, "creative": 1, "adventure": 2, "spectator": 3} + +func (ret *PlayToServerPacketChangeGamemode) Encode(w io.Writer) (err error) { + var vPlayToServerPacketChangeGamemodeMode int32 + vPlayToServerPacketChangeGamemodeMode, err = proto_base.ErroringIndex(PlayToServerPacketChangeGamemodeModeReverseMap, ret.Mode) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToServerPacketChangeGamemodeMode) + if err != nil { + return + } + return +} + +type PlayToServerPacketChatCommand struct { + Command string +} + +func (ret *PlayToServerPacketChatCommand) Decode(r io.Reader) (err error) { + ret.Command, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketChatCommand) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Command) + if err != nil { + return + } + return +} + +type PlayToServerPacketChatCommandSigned struct { + Command string + Timestamp int64 + Salt int64 + ArgumentSignatures []struct { + ArgumentName string + Signature [256]byte + } + MessageCount int32 + Acknowledged [3]byte + Checksum int8 +} + +func (ret *PlayToServerPacketChatCommandSigned) Decode(r io.Reader) (err error) { + ret.Command, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Timestamp) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Salt) + if err != nil { + return + } + var lPlayToServerPacketChatCommandSignedArgumentSignatures int32 + lPlayToServerPacketChatCommandSignedArgumentSignatures, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ArgumentSignatures = []struct { + ArgumentName string + Signature [256]byte + }{} + for range lPlayToServerPacketChatCommandSignedArgumentSignatures { + var PlayToServerPacketChatCommandSignedArgumentSignaturesElement struct { + ArgumentName string + Signature [256]byte + } + PlayToServerPacketChatCommandSignedArgumentSignaturesElement.ArgumentName, err = proto_base.DecodeString(r) + if err != nil { + return + } + _, err = r.Read(PlayToServerPacketChatCommandSignedArgumentSignaturesElement.Signature[:]) + if err != nil { + return + } + ret.ArgumentSignatures = append(ret.ArgumentSignatures, PlayToServerPacketChatCommandSignedArgumentSignaturesElement) + } + ret.MessageCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + _, err = r.Read(ret.Acknowledged[:]) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Checksum) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketChatCommandSigned) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Command) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Timestamp) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Salt) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.ArgumentSignatures))) + if err != nil { + return + } + for iPlayToServerPacketChatCommandSignedArgumentSignatures := range len(ret.ArgumentSignatures) { + err = proto_base.EncodeString(w, ret.ArgumentSignatures[iPlayToServerPacketChatCommandSignedArgumentSignatures].ArgumentName) + if err != nil { + return + } + arr := ret.ArgumentSignatures[iPlayToServerPacketChatCommandSignedArgumentSignatures].Signature + _, err = w.Write(arr[:]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, ret.MessageCount) + if err != nil { + return + } + arr := ret.Acknowledged + _, err = w.Write(arr[:]) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Checksum) + if err != nil { + return + } + return +} + +type PlayToServerPacketChatMessage struct { + Message string + Timestamp int64 + Salt int64 + Signature *[256]byte + Offset int32 + Acknowledged [3]byte + Checksum uint8 +} + +func (ret *PlayToServerPacketChatMessage) Decode(r io.Reader) (err error) { + ret.Message, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Timestamp) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Salt) + if err != nil { + return + } + var PlayToServerPacketChatMessageSignaturePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketChatMessageSignaturePresent) + if err != nil { + return + } + if PlayToServerPacketChatMessageSignaturePresent { + var PlayToServerPacketChatMessageSignaturePresentValue [256]byte + _, err = r.Read(PlayToServerPacketChatMessageSignaturePresentValue[:]) + if err != nil { + return + } + ret.Signature = &PlayToServerPacketChatMessageSignaturePresentValue + } + ret.Offset, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + _, err = r.Read(ret.Acknowledged[:]) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Checksum) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketChatMessage) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Message) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Timestamp) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Salt) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Signature != nil) + if err != nil { + return + } + if ret.Signature != nil { + arr := *ret.Signature + _, err = w.Write(arr[:]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, ret.Offset) + if err != nil { + return + } + arr := ret.Acknowledged + _, err = w.Write(arr[:]) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Checksum) + if err != nil { + return + } + return +} + +type PlayToServerPacketChatSessionUpdate struct { + SessionUUID uuid.UUID + ExpireTime int64 + PublicKey ByteArray + Signature ByteArray +} + +func (ret *PlayToServerPacketChatSessionUpdate) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.SessionUUID[:]) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ExpireTime) + if err != nil { + return + } + err = ret.PublicKey.Decode(r) + if err != nil { + return + } + err = ret.Signature.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketChatSessionUpdate) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.SessionUUID[:]) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ExpireTime) + if err != nil { + return + } + err = ret.PublicKey.Encode(w) + if err != nil { + return + } + err = ret.Signature.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketChunkBatchReceived struct { + ChunksPerTick float32 +} + +func (ret *PlayToServerPacketChunkBatchReceived) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.ChunksPerTick) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketChunkBatchReceived) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.ChunksPerTick) + if err != nil { + return + } + return +} + +type PlayToServerPacketClientCommand struct { + ActionId int32 +} + +func (ret *PlayToServerPacketClientCommand) Decode(r io.Reader) (err error) { + ret.ActionId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketClientCommand) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.ActionId) + if err != nil { + return + } + return +} + +type PlayToServerPacketCloseWindow struct { + WindowId ContainerID +} + +func (ret *PlayToServerPacketCloseWindow) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketCloseWindow) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketCommonAddResourcePack struct { + Uuid uuid.UUID + Url string + Hash string + Forced bool + PromptMessage *nbt.Anon +} + +func (ret *PlayToServerPacketCommonAddResourcePack) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Url, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Hash, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Forced) + if err != nil { + return + } + var PlayToServerPacketCommonAddResourcePackPromptMessagePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonAddResourcePackPromptMessagePresent) + if err != nil { + return + } + if PlayToServerPacketCommonAddResourcePackPromptMessagePresent { + var PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon + err = PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.PromptMessage = &PlayToServerPacketCommonAddResourcePackPromptMessagePresentValue + } + return +} +func (ret *PlayToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Url) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Hash) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Forced) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) + if err != nil { + return + } + if ret.PromptMessage != nil { + err = (*ret.PromptMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketCommonClearDialog struct { +} + +func (ret *PlayToServerPacketCommonClearDialog) Decode(r io.Reader) (err error) { + return +} +func (ret *PlayToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) { + return +} + +type PlayToServerPacketCommonCookieRequest struct { + Cookie string +} + +func (ret *PlayToServerPacketCommonCookieRequest) Decode(r io.Reader) (err error) { + ret.Cookie, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Cookie) + if err != nil { + return + } + return +} + +type PlayToServerPacketCommonCookieResponse struct { + Key string + Value *ByteArray +} + +func (ret *PlayToServerPacketCommonCookieResponse) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var PlayToServerPacketCommonCookieResponseValuePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonCookieResponseValuePresent) + if err != nil { + return + } + if PlayToServerPacketCommonCookieResponseValuePresent { + var PlayToServerPacketCommonCookieResponseValuePresentValue ByteArray + err = PlayToServerPacketCommonCookieResponseValuePresentValue.Decode(r) + if err != nil { + return + } + ret.Value = &PlayToServerPacketCommonCookieResponseValuePresentValue + } + return +} +func (ret *PlayToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value != nil) + if err != nil { + return + } + if ret.Value != nil { + err = (*ret.Value).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketCommonCustomClickAction struct { + Id string + Nbt *nbt.Anon +} + +func (ret *PlayToServerPacketCommonCustomClickAction) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var PlayToServerPacketCommonCustomClickActionNbtPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonCustomClickActionNbtPresent) + if err != nil { + return + } + if PlayToServerPacketCommonCustomClickActionNbtPresent { + var PlayToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon + err = PlayToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r) + if err != nil { + return + } + ret.Nbt = &PlayToServerPacketCommonCustomClickActionNbtPresentValue + } + return +} +func (ret *PlayToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) + if err != nil { + return + } + if ret.Nbt != nil { + err = (*ret.Nbt).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketCommonCustomReportDetails struct { + Details []struct { + Key string + Value string + } +} + +func (ret *PlayToServerPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) { + var lPlayToServerPacketCommonCustomReportDetailsDetails int32 + lPlayToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Details = []struct { + Key string + Value string + }{} + for range lPlayToServerPacketCommonCustomReportDetailsDetails { + var PlayToServerPacketCommonCustomReportDetailsDetailsElement struct { + Key string + Value string + } + PlayToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Details = append(ret.Details, PlayToServerPacketCommonCustomReportDetailsDetailsElement) + } + return +} +func (ret *PlayToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) + if err != nil { + return + } + for iPlayToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) { + err = proto_base.EncodeString(w, ret.Details[iPlayToServerPacketCommonCustomReportDetailsDetails].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Details[iPlayToServerPacketCommonCustomReportDetailsDetails].Value) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketCommonRemoveResourcePack struct { + Uuid *uuid.UUID +} + +func (ret *PlayToServerPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) { + var PlayToServerPacketCommonRemoveResourcePackUuidPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonRemoveResourcePackUuidPresent) + if err != nil { + return + } + if PlayToServerPacketCommonRemoveResourcePackUuidPresent { + var PlayToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID + _, err = io.ReadFull(r, PlayToServerPacketCommonRemoveResourcePackUuidPresentValue[:]) + if err != nil { + return + } + ret.Uuid = &PlayToServerPacketCommonRemoveResourcePackUuidPresentValue + } + return +} +func (ret *PlayToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) + if err != nil { + return + } + if ret.Uuid != nil { + _, err = w.Write((*ret.Uuid)[:]) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketCommonSelectKnownPacks struct { + Packs []struct { + Namespace string + Id string + Version string + } +} + +func (ret *PlayToServerPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) { + var lPlayToServerPacketCommonSelectKnownPacksPacks int32 + lPlayToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Packs = []struct { + Namespace string + Id string + Version string + }{} + for range lPlayToServerPacketCommonSelectKnownPacksPacks { + var PlayToServerPacketCommonSelectKnownPacksPacksElement struct { + Namespace string + Id string + Version string + } + PlayToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + PlayToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Packs = append(ret.Packs, PlayToServerPacketCommonSelectKnownPacksPacksElement) + } + return +} +func (ret *PlayToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) + if err != nil { + return + } + for iPlayToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { + err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Namespace) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Id) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iPlayToServerPacketCommonSelectKnownPacksPacks].Version) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketCommonServerLinks struct { + Links []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } +} + +func (ret *PlayToServerPacketCommonServerLinks) Decode(r io.Reader) (err error) { + var lPlayToServerPacketCommonServerLinksLinks int32 + lPlayToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Links = []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + }{} + for range lPlayToServerPacketCommonServerLinksLinks { + var PlayToServerPacketCommonServerLinksLinksElement struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketCommonServerLinksLinksElement.HasKnownType) + if err != nil { + return + } + switch PlayToServerPacketCommonServerLinksLinksElement.HasKnownType { + case true: + var PlayToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType + err = PlayToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) + if err != nil { + return + } + PlayToServerPacketCommonServerLinksLinksElement.KnownType = PlayToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp + } + switch PlayToServerPacketCommonServerLinksLinksElement.HasKnownType { + case false: + var PlayToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon + err = PlayToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) + if err != nil { + return + } + PlayToServerPacketCommonServerLinksLinksElement.UnknownType = PlayToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp + } + PlayToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Links = append(ret.Links, PlayToServerPacketCommonServerLinksLinksElement) + } + return +} +func (ret *PlayToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) + if err != nil { + return + } + for iPlayToServerPacketCommonServerLinksLinks := range len(ret.Links) { + err = binary.Write(w, binary.BigEndian, ret.Links[iPlayToServerPacketCommonServerLinksLinks].HasKnownType) + if err != nil { + return + } + switch ret.Links[iPlayToServerPacketCommonServerLinksLinks].HasKnownType { + case true: + PlayToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iPlayToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketCommonServerLinksLinksInnerKnownType.Encode(w) + if err != nil { + return + } + } + switch ret.Links[iPlayToServerPacketCommonServerLinksLinks].HasKnownType { + case false: + PlayToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iPlayToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = PlayToServerPacketCommonServerLinksLinksInnerUnknownType.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Links[iPlayToServerPacketCommonServerLinksLinks].Link) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketCommonSettings struct { + Locale string + ViewDistance int8 + ChatFlags int32 + ChatColors bool + SkinParts uint8 + MainHand int32 + EnableTextFiltering bool + EnableServerListing bool + ParticleStatus string +} + +var PlayToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} + +func (ret *PlayToServerPacketCommonSettings) Decode(r io.Reader) (err error) { + ret.Locale, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ViewDistance) + if err != nil { + return + } + ret.ChatFlags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChatColors) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SkinParts) + if err != nil { + return + } + ret.MainHand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) + if err != nil { + return + } + var PlayToServerPacketCommonSettingsParticleStatusKey int32 + PlayToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ParticleStatus, err = proto_base.ErroringIndex(PlayToServerPacketCommonSettingsParticleStatusMap, PlayToServerPacketCommonSettingsParticleStatusKey) + if err != nil { + return + } + return +} + +var PlayToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} + +func (ret *PlayToServerPacketCommonSettings) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Locale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChatFlags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChatColors) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SkinParts) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.MainHand) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) + if err != nil { + return + } + var vPlayToServerPacketCommonSettingsParticleStatus int32 + vPlayToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(PlayToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToServerPacketCommonSettingsParticleStatus) + if err != nil { + return + } + return +} + +type PlayToServerPacketCommonStoreCookie struct { + Key string + Value ByteArray +} + +func (ret *PlayToServerPacketCommonStoreCookie) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Value.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = ret.Value.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketCommonTransfer struct { + Host string + Port int32 +} + +func (ret *PlayToServerPacketCommonTransfer) Decode(r io.Reader) (err error) { + ret.Host, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Port, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketCommonTransfer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Host) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Port) + if err != nil { + return + } + return +} + +type PlayToServerPacketConfigurationAcknowledged struct { +} + +func (ret *PlayToServerPacketConfigurationAcknowledged) Decode(r io.Reader) (err error) { + return +} +func (ret *PlayToServerPacketConfigurationAcknowledged) Encode(w io.Writer) (err error) { + return +} + +type PlayToServerPacketCraftRecipeRequest struct { + WindowId ContainerID + RecipeId int32 + MakeAll bool +} + +func (ret *PlayToServerPacketCraftRecipeRequest) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + ret.RecipeId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.MakeAll) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketCraftRecipeRequest) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.RecipeId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.MakeAll) + if err != nil { + return + } + return +} + +type PlayToServerPacketCustomPayload struct { + Channel string + Data proto_base.RestBuffer +} + +func (ret *PlayToServerPacketCustomPayload) Decode(r io.Reader) (err error) { + ret.Channel, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Data.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketCustomPayload) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Channel) + if err != nil { + return + } + err = ret.Data.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketDebugSampleSubscription struct { + Type int32 +} + +func (ret *PlayToServerPacketDebugSampleSubscription) Decode(r io.Reader) (err error) { + ret.Type, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketDebugSampleSubscription) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Type) + if err != nil { + return + } + return +} + +type PlayToServerPacketDisplayedRecipe struct { + RecipeId int32 +} + +func (ret *PlayToServerPacketDisplayedRecipe) Decode(r io.Reader) (err error) { + ret.RecipeId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketDisplayedRecipe) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.RecipeId) + if err != nil { + return + } + return +} + +type PlayToServerPacketEditBook struct { + Hand int32 + Pages []string + Title *string +} + +func (ret *PlayToServerPacketEditBook) Decode(r io.Reader) (err error) { + ret.Hand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lPlayToServerPacketEditBookPages int32 + lPlayToServerPacketEditBookPages, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Pages = []string{} + for range lPlayToServerPacketEditBookPages { + var PlayToServerPacketEditBookPagesElement string + PlayToServerPacketEditBookPagesElement, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Pages = append(ret.Pages, PlayToServerPacketEditBookPagesElement) + } + var PlayToServerPacketEditBookTitlePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketEditBookTitlePresent) + if err != nil { + return + } + if PlayToServerPacketEditBookTitlePresent { + var PlayToServerPacketEditBookTitlePresentValue string + PlayToServerPacketEditBookTitlePresentValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Title = &PlayToServerPacketEditBookTitlePresentValue + } + return +} +func (ret *PlayToServerPacketEditBook) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Hand) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Pages))) + if err != nil { + return + } + for iPlayToServerPacketEditBookPages := range len(ret.Pages) { + err = proto_base.EncodeString(w, ret.Pages[iPlayToServerPacketEditBookPages]) + if err != nil { + return + } + } + err = binary.Write(w, binary.BigEndian, ret.Title != nil) + if err != nil { + return + } + if ret.Title != nil { + err = proto_base.EncodeString(w, *ret.Title) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketEnchantItem struct { + WindowId ContainerID + Enchantment int8 +} + +func (ret *PlayToServerPacketEnchantItem) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Enchantment) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketEnchantItem) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Enchantment) + if err != nil { + return + } + return +} + +type PlayToServerPacketEntityAction struct { + EntityId int32 + ActionId string + JumpBoost int32 +} + +var PlayToServerPacketEntityActionActionIdMap = map[int32]string{0: "leave_bed", 1: "start_sprinting", 2: "stop_sprinting", 3: "start_horse_jump", 4: "stop_horse_jump", 5: "open_vehicle_inventory", 6: "start_elytra_flying"} + +func (ret *PlayToServerPacketEntityAction) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var PlayToServerPacketEntityActionActionIdKey int32 + PlayToServerPacketEntityActionActionIdKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ActionId, err = proto_base.ErroringIndex(PlayToServerPacketEntityActionActionIdMap, PlayToServerPacketEntityActionActionIdKey) + if err != nil { + return + } + ret.JumpBoost, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} + +var PlayToServerPacketEntityActionActionIdReverseMap = map[string]int32{"leave_bed": 0, "start_sprinting": 1, "stop_sprinting": 2, "start_horse_jump": 3, "stop_horse_jump": 4, "open_vehicle_inventory": 5, "start_elytra_flying": 6} + +func (ret *PlayToServerPacketEntityAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + var vPlayToServerPacketEntityActionActionId int32 + vPlayToServerPacketEntityActionActionId, err = proto_base.ErroringIndex(PlayToServerPacketEntityActionActionIdReverseMap, ret.ActionId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToServerPacketEntityActionActionId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.JumpBoost) + if err != nil { + return + } + return +} + +type PlayToServerPacketFlying struct { + Flags PlayToServerMovementFlags +} + +func (ret *PlayToServerPacketFlying) Decode(r io.Reader) (err error) { + err = ret.Flags.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketFlying) Encode(w io.Writer) (err error) { + err = ret.Flags.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketGenerateStructure struct { + Location Position + Levels int32 + KeepJigsaws bool +} + +func (ret *PlayToServerPacketGenerateStructure) Decode(r io.Reader) (err error) { + err = ret.Location.Decode(r) + if err != nil { + return + } + ret.Levels, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.KeepJigsaws) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketGenerateStructure) Encode(w io.Writer) (err error) { + err = ret.Location.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Levels) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.KeepJigsaws) + if err != nil { + return + } + return +} + +type PlayToServerPacketHeldItemSlot struct { + SlotId int16 +} + +func (ret *PlayToServerPacketHeldItemSlot) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.SlotId) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketHeldItemSlot) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.SlotId) + if err != nil { + return + } + return +} + +type PlayToServerPacketKeepAlive struct { + KeepAliveId int64 +} + +func (ret *PlayToServerPacketKeepAlive) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketKeepAlive) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.KeepAliveId) + if err != nil { + return + } + return +} + +type PlayToServerPacketLockDifficulty struct { + Locked bool +} + +func (ret *PlayToServerPacketLockDifficulty) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Locked) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketLockDifficulty) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Locked) + if err != nil { + return + } + return +} + +type PlayToServerPacketLook struct { + Yaw float32 + Pitch float32 + Flags PlayToServerMovementFlags +} + +func (ret *PlayToServerPacketLook) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = ret.Flags.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketLook) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = ret.Flags.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketMessageAcknowledgement struct { + Count int32 +} + +func (ret *PlayToServerPacketMessageAcknowledgement) Decode(r io.Reader) (err error) { + ret.Count, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketMessageAcknowledgement) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Count) + if err != nil { + return + } + return +} + +type PlayToServerPacketNameItem struct { + Name string +} + +func (ret *PlayToServerPacketNameItem) Decode(r io.Reader) (err error) { + ret.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketNameItem) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Name) + if err != nil { + return + } + return +} + +type PlayToServerPacketPickItemFromBlock struct { + Position Position + IncludeData bool +} + +func (ret *PlayToServerPacketPickItemFromBlock) Decode(r io.Reader) (err error) { + err = ret.Position.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IncludeData) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketPickItemFromBlock) Encode(w io.Writer) (err error) { + err = ret.Position.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IncludeData) + if err != nil { + return + } + return +} + +type PlayToServerPacketPickItemFromEntity struct { + EntityId int32 + IncludeData bool +} + +func (ret *PlayToServerPacketPickItemFromEntity) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IncludeData) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketPickItemFromEntity) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IncludeData) + if err != nil { + return + } + return +} + +type PlayToServerPacketPingRequest struct { + Id int64 +} + +func (ret *PlayToServerPacketPingRequest) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Id) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketPingRequest) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Id) + if err != nil { + return + } + return +} + +type PlayToServerPacketPlayerInput struct { + Inputs uint8 +} + +func (ret *PlayToServerPacketPlayerInput) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Inputs) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketPlayerInput) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Inputs) + if err != nil { + return + } + return +} + +type PlayToServerPacketPlayerLoaded struct { +} + +func (ret *PlayToServerPacketPlayerLoaded) Decode(r io.Reader) (err error) { + return +} +func (ret *PlayToServerPacketPlayerLoaded) Encode(w io.Writer) (err error) { + return +} + +type PlayToServerPacketPong struct { + Id int32 +} + +func (ret *PlayToServerPacketPong) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Id) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketPong) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Id) + if err != nil { + return + } + return +} + +type PlayToServerPacketPosition struct { + X float64 + Y float64 + Z float64 + Flags PlayToServerMovementFlags +} + +func (ret *PlayToServerPacketPosition) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = ret.Flags.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketPosition) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = ret.Flags.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketPositionLook struct { + X float64 + Y float64 + Z float64 + Yaw float32 + Pitch float32 + Flags PlayToServerMovementFlags +} + +func (ret *PlayToServerPacketPositionLook) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = ret.Flags.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketPositionLook) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = ret.Flags.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketQueryBlockNbt struct { + TransactionId int32 + Location Position +} + +func (ret *PlayToServerPacketQueryBlockNbt) Decode(r io.Reader) (err error) { + ret.TransactionId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.Location.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketQueryBlockNbt) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.TransactionId) + if err != nil { + return + } + err = ret.Location.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketQueryEntityNbt struct { + TransactionId int32 + EntityId int32 +} + +func (ret *PlayToServerPacketQueryEntityNbt) Decode(r io.Reader) (err error) { + ret.TransactionId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketQueryEntityNbt) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.TransactionId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + return +} + +type PlayToServerPacketRecipeBook struct { + BookId int32 + BookOpen bool + FilterActive bool +} + +func (ret *PlayToServerPacketRecipeBook) Decode(r io.Reader) (err error) { + ret.BookId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.BookOpen) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.FilterActive) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketRecipeBook) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.BookId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.BookOpen) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.FilterActive) + if err != nil { + return + } + return +} + +type PlayToServerPacketResourcePackReceive struct { + Uuid uuid.UUID + Result int32 +} + +func (ret *PlayToServerPacketResourcePackReceive) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Result, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Result) + if err != nil { + return + } + return +} + +type PlayToServerPacketSelectBundleItem struct { + SlotId int32 + SelectedItemIndex int32 +} + +func (ret *PlayToServerPacketSelectBundleItem) Decode(r io.Reader) (err error) { + ret.SlotId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SelectedItemIndex, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketSelectBundleItem) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.SlotId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.SelectedItemIndex) + if err != nil { + return + } + return +} + +type PlayToServerPacketSelectTrade struct { + Slot int32 +} + +func (ret *PlayToServerPacketSelectTrade) Decode(r io.Reader) (err error) { + ret.Slot, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketSelectTrade) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Slot) + if err != nil { + return + } + return +} + +type PlayToServerPacketSetBeaconEffect struct { + PrimaryEffect *int32 + SecondaryEffect *int32 +} + +func (ret *PlayToServerPacketSetBeaconEffect) Decode(r io.Reader) (err error) { + var PlayToServerPacketSetBeaconEffectPrimaryEffectPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketSetBeaconEffectPrimaryEffectPresent) + if err != nil { + return + } + if PlayToServerPacketSetBeaconEffectPrimaryEffectPresent { + var PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue int32 + PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.PrimaryEffect = &PlayToServerPacketSetBeaconEffectPrimaryEffectPresentValue + } + var PlayToServerPacketSetBeaconEffectSecondaryEffectPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketSetBeaconEffectSecondaryEffectPresent) + if err != nil { + return + } + if PlayToServerPacketSetBeaconEffectSecondaryEffectPresent { + var PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue int32 + PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SecondaryEffect = &PlayToServerPacketSetBeaconEffectSecondaryEffectPresentValue + } + return +} +func (ret *PlayToServerPacketSetBeaconEffect) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.PrimaryEffect != nil) + if err != nil { + return + } + if ret.PrimaryEffect != nil { + err = proto_base.EncodeVarInt(w, *ret.PrimaryEffect) + if err != nil { + return + } + } + err = binary.Write(w, binary.BigEndian, ret.SecondaryEffect != nil) + if err != nil { + return + } + if ret.SecondaryEffect != nil { + err = proto_base.EncodeVarInt(w, *ret.SecondaryEffect) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketSetCreativeSlot struct { + Slot int16 + Item UntrustedSlot +} + +func (ret *PlayToServerPacketSetCreativeSlot) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Slot) + if err != nil { + return + } + err = ret.Item.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketSetCreativeSlot) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Slot) + if err != nil { + return + } + err = ret.Item.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketSetDifficulty struct { + NewDifficulty string +} + +var PlayToServerPacketSetDifficultyNewDifficultyMap = map[int32]string{0: "peaceful", 1: "easy", 2: "normal", 3: "hard"} + +func (ret *PlayToServerPacketSetDifficulty) Decode(r io.Reader) (err error) { + var PlayToServerPacketSetDifficultyNewDifficultyKey int32 + PlayToServerPacketSetDifficultyNewDifficultyKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.NewDifficulty, err = proto_base.ErroringIndex(PlayToServerPacketSetDifficultyNewDifficultyMap, PlayToServerPacketSetDifficultyNewDifficultyKey) + if err != nil { + return + } + return +} + +var PlayToServerPacketSetDifficultyNewDifficultyReverseMap = map[string]int32{"peaceful": 0, "easy": 1, "normal": 2, "hard": 3} + +func (ret *PlayToServerPacketSetDifficulty) Encode(w io.Writer) (err error) { + var vPlayToServerPacketSetDifficultyNewDifficulty int32 + vPlayToServerPacketSetDifficultyNewDifficulty, err = proto_base.ErroringIndex(PlayToServerPacketSetDifficultyNewDifficultyReverseMap, ret.NewDifficulty) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vPlayToServerPacketSetDifficultyNewDifficulty) + if err != nil { + return + } + return +} + +type PlayToServerPacketSetSlotState struct { + SlotId int32 + WindowId ContainerID + State bool +} + +func (ret *PlayToServerPacketSetSlotState) Decode(r io.Reader) (err error) { + ret.SlotId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.WindowId.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.State) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketSetSlotState) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.SlotId) + if err != nil { + return + } + err = ret.WindowId.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.State) + if err != nil { + return + } + return +} + +type PlayToServerPacketSetTestBlock struct { + Position Position + Mode int32 + Message string +} + +func (ret *PlayToServerPacketSetTestBlock) Decode(r io.Reader) (err error) { + err = ret.Position.Decode(r) + if err != nil { + return + } + ret.Mode, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Message, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketSetTestBlock) Encode(w io.Writer) (err error) { + err = ret.Position.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Mode) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Message) + if err != nil { + return + } + return +} + +type PlayToServerPacketSpectate struct { + Target uuid.UUID +} + +func (ret *PlayToServerPacketSpectate) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Target[:]) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketSpectate) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Target[:]) + if err != nil { + return + } + return +} + +type PlayToServerPacketSteerBoat struct { + LeftPaddle bool + RightPaddle bool +} + +func (ret *PlayToServerPacketSteerBoat) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.LeftPaddle) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.RightPaddle) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketSteerBoat) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.LeftPaddle) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.RightPaddle) + if err != nil { + return + } + return +} + +type PlayToServerPacketTabComplete struct { + TransactionId int32 + Text string +} + +func (ret *PlayToServerPacketTabComplete) Decode(r io.Reader) (err error) { + ret.TransactionId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Text, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketTabComplete) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.TransactionId) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Text) + if err != nil { + return + } + return +} + +type PlayToServerPacketTeleportConfirm struct { + TeleportId int32 +} + +func (ret *PlayToServerPacketTeleportConfirm) Decode(r io.Reader) (err error) { + ret.TeleportId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketTeleportConfirm) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.TeleportId) + if err != nil { + return + } + return +} + +type PlayToServerPacketTestInstanceBlockAction struct { + Pos Position + Action int32 + Data struct { + Test *string + Size Vec3i + Rotation int32 + IgnoreEntities bool + Status int32 + ErrorMessage *nbt.Anon + } +} + +func (ret *PlayToServerPacketTestInstanceBlockAction) Decode(r io.Reader) (err error) { + err = ret.Pos.Decode(r) + if err != nil { + return + } + ret.Action, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var PlayToServerPacketTestInstanceBlockActionDataTestPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketTestInstanceBlockActionDataTestPresent) + if err != nil { + return + } + if PlayToServerPacketTestInstanceBlockActionDataTestPresent { + var PlayToServerPacketTestInstanceBlockActionDataTestPresentValue string + PlayToServerPacketTestInstanceBlockActionDataTestPresentValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Data.Test = &PlayToServerPacketTestInstanceBlockActionDataTestPresentValue + } + err = ret.Data.Size.Decode(r) + if err != nil { + return + } + ret.Data.Rotation, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Data.IgnoreEntities) + if err != nil { + return + } + ret.Data.Status, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresent) + if err != nil { + return + } + if PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresent { + var PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue nbt.Anon + err = PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.Data.ErrorMessage = &PlayToServerPacketTestInstanceBlockActionDataErrorMessagePresentValue + } + return +} +func (ret *PlayToServerPacketTestInstanceBlockAction) Encode(w io.Writer) (err error) { + err = ret.Pos.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Action) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Data.Test != nil) + if err != nil { + return + } + if ret.Data.Test != nil { + err = proto_base.EncodeString(w, *ret.Data.Test) + if err != nil { + return + } + } + err = ret.Data.Size.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Data.Rotation) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Data.IgnoreEntities) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Data.Status) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Data.ErrorMessage != nil) + if err != nil { + return + } + if ret.Data.ErrorMessage != nil { + err = (*ret.Data.ErrorMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type PlayToServerPacketTickEnd struct { +} + +func (ret *PlayToServerPacketTickEnd) Decode(r io.Reader) (err error) { + return +} +func (ret *PlayToServerPacketTickEnd) Encode(w io.Writer) (err error) { + return +} + +type PlayToServerPacketUpdateCommandBlock struct { + Location Position + Command string + Mode int32 + Flags uint8 +} + +func (ret *PlayToServerPacketUpdateCommandBlock) Decode(r io.Reader) (err error) { + err = ret.Location.Decode(r) + if err != nil { + return + } + ret.Command, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Mode, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Flags) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketUpdateCommandBlock) Encode(w io.Writer) (err error) { + err = ret.Location.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Command) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Mode) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Flags) + if err != nil { + return + } + return +} + +type PlayToServerPacketUpdateCommandBlockMinecart struct { + EntityId int32 + Command string + TrackOutput bool +} + +func (ret *PlayToServerPacketUpdateCommandBlockMinecart) Decode(r io.Reader) (err error) { + ret.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Command, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.TrackOutput) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketUpdateCommandBlockMinecart) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.EntityId) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Command) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.TrackOutput) + if err != nil { + return + } + return +} + +type PlayToServerPacketUpdateJigsawBlock struct { + Location Position + Name string + Target string + Pool string + FinalState string + JointType string + SelectionPriority int32 + PlacementPriority int32 +} + +func (ret *PlayToServerPacketUpdateJigsawBlock) Decode(r io.Reader) (err error) { + err = ret.Location.Decode(r) + if err != nil { + return + } + ret.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Target, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Pool, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.FinalState, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.JointType, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.SelectionPriority, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.PlacementPriority, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketUpdateJigsawBlock) Encode(w io.Writer) (err error) { + err = ret.Location.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Target) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Pool) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.FinalState) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.JointType) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.SelectionPriority) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.PlacementPriority) + if err != nil { + return + } + return +} + +type PlayToServerPacketUpdateSign struct { + Location Position + IsFrontText bool + Text1 string + Text2 string + Text3 string + Text4 string +} + +func (ret *PlayToServerPacketUpdateSign) Decode(r io.Reader) (err error) { + err = ret.Location.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IsFrontText) + if err != nil { + return + } + ret.Text1, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Text2, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Text3, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Text4, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketUpdateSign) Encode(w io.Writer) (err error) { + err = ret.Location.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IsFrontText) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Text1) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Text2) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Text3) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Text4) + if err != nil { + return + } + return +} + +type PlayToServerPacketUpdateStructureBlock struct { + Location Position + Action int32 + Mode int32 + Name string + OffsetX int8 + OffsetY int8 + OffsetZ int8 + SizeX int8 + SizeY int8 + SizeZ int8 + Mirror int32 + Rotation int32 + Metadata string + Integrity float32 + Seed int32 + Flags string +} + +var PlayToServerPacketUpdateStructureBlockFlagsMap = map[uint8]string{0: "ignore_entities", 1: "show_air", 2: "show_bounding_box", 3: "strict"} + +func (ret *PlayToServerPacketUpdateStructureBlock) Decode(r io.Reader) (err error) { + err = ret.Location.Decode(r) + if err != nil { + return + } + ret.Action, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Mode, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OffsetX) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OffsetY) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OffsetZ) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SizeX) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SizeY) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SizeZ) + if err != nil { + return + } + ret.Mirror, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Rotation, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Metadata, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Integrity) + if err != nil { + return + } + ret.Seed, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var PlayToServerPacketUpdateStructureBlockFlagsKey uint8 + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUpdateStructureBlockFlagsKey) + if err != nil { + return + } + ret.Flags, err = proto_base.ErroringIndex(PlayToServerPacketUpdateStructureBlockFlagsMap, PlayToServerPacketUpdateStructureBlockFlagsKey) + if err != nil { + return + } + return +} + +var PlayToServerPacketUpdateStructureBlockFlagsReverseMap = map[string]uint8{"ignore_entities": 0, "show_air": 1, "show_bounding_box": 2, "strict": 3} + +func (ret *PlayToServerPacketUpdateStructureBlock) Encode(w io.Writer) (err error) { + err = ret.Location.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Action) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Mode) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Name) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OffsetX) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OffsetY) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OffsetZ) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SizeX) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SizeY) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SizeZ) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Mirror) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Rotation) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Metadata) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Integrity) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Seed) + if err != nil { + return + } + var vPlayToServerPacketUpdateStructureBlockFlags uint8 + vPlayToServerPacketUpdateStructureBlockFlags, err = proto_base.ErroringIndex(PlayToServerPacketUpdateStructureBlockFlagsReverseMap, ret.Flags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, vPlayToServerPacketUpdateStructureBlockFlags) + if err != nil { + return + } + return +} + +type PlayToServerPacketUseEntity struct { + Target int32 + Mouse int32 + X any + Y any + Z any + Hand any + Sneaking bool +} + +func (ret *PlayToServerPacketUseEntity) Decode(r io.Reader) (err error) { + ret.Target, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Mouse, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + switch ret.Mouse { + case 2: + var PlayToServerPacketUseEntityX2Tmp float32 + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityX2Tmp) + if err != nil { + return + } + ret.X = PlayToServerPacketUseEntityX2Tmp + default: + var PlayToServerPacketUseEntityXTmp struct { + } + ret.X = PlayToServerPacketUseEntityXTmp + } + switch ret.Mouse { + case 2: + var PlayToServerPacketUseEntityY2Tmp float32 + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityY2Tmp) + if err != nil { + return + } + ret.Y = PlayToServerPacketUseEntityY2Tmp + default: + var PlayToServerPacketUseEntityYTmp struct { + } + ret.Y = PlayToServerPacketUseEntityYTmp + } + switch ret.Mouse { + case 2: + var PlayToServerPacketUseEntityZ2Tmp float32 + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketUseEntityZ2Tmp) + if err != nil { + return + } + ret.Z = PlayToServerPacketUseEntityZ2Tmp + default: + var PlayToServerPacketUseEntityZTmp struct { + } + ret.Z = PlayToServerPacketUseEntityZTmp + } + switch ret.Mouse { + case 0: + var PlayToServerPacketUseEntityHand0Tmp int32 + PlayToServerPacketUseEntityHand0Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Hand = PlayToServerPacketUseEntityHand0Tmp + case 2: + var PlayToServerPacketUseEntityHand2Tmp int32 + PlayToServerPacketUseEntityHand2Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Hand = PlayToServerPacketUseEntityHand2Tmp + default: + var PlayToServerPacketUseEntityHandTmp struct { + } + ret.Hand = PlayToServerPacketUseEntityHandTmp + } + err = binary.Read(r, binary.BigEndian, &ret.Sneaking) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketUseEntity) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Target) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Mouse) + if err != nil { + return + } + switch ret.Mouse { + case 2: + PlayToServerPacketUseEntityX, ok := ret.X.(float32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityX) + if err != nil { + return + } + default: + _, ok := ret.X.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Mouse { + case 2: + PlayToServerPacketUseEntityY, ok := ret.Y.(float32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityY) + if err != nil { + return + } + default: + _, ok := ret.Y.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Mouse { + case 2: + PlayToServerPacketUseEntityZ, ok := ret.Z.(float32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, PlayToServerPacketUseEntityZ) + if err != nil { + return + } + default: + _, ok := ret.Z.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Mouse { + case 0: + PlayToServerPacketUseEntityHand, ok := ret.Hand.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToServerPacketUseEntityHand) + if err != nil { + return + } + case 2: + PlayToServerPacketUseEntityHand, ok := ret.Hand.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, PlayToServerPacketUseEntityHand) + if err != nil { + return + } + default: + _, ok := ret.Hand.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + err = binary.Write(w, binary.BigEndian, ret.Sneaking) + if err != nil { + return + } + return +} + +type PlayToServerPacketUseItem struct { + Hand int32 + Sequence int32 + Rotation Vec2f +} + +func (ret *PlayToServerPacketUseItem) Decode(r io.Reader) (err error) { + ret.Hand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Sequence, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.Rotation.Decode(r) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketUseItem) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Hand) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Sequence) + if err != nil { + return + } + err = ret.Rotation.Encode(w) + if err != nil { + return + } + return +} + +type PlayToServerPacketVehicleMove struct { + X float64 + Y float64 + Z float64 + Yaw float32 + Pitch float32 + OnGround bool +} + +func (ret *PlayToServerPacketVehicleMove) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Pitch) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.OnGround) + if err != nil { + return + } + return +} +func (ret *PlayToServerPacketVehicleMove) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Pitch) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.OnGround) + if err != nil { + return + } + return +} + +type PlayToServerPacketWindowClick struct { + WindowId ContainerID + StateId int32 + Slot int16 + MouseButton int8 + Mode int32 + ChangedSlots []struct { + Location int16 + Item *HashedSlot + } + CursorItem *HashedSlot +} + +func (ret *PlayToServerPacketWindowClick) Decode(r io.Reader) (err error) { + err = ret.WindowId.Decode(r) + if err != nil { + return + } + ret.StateId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Slot) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.MouseButton) + if err != nil { + return + } + ret.Mode, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lPlayToServerPacketWindowClickChangedSlots int32 + lPlayToServerPacketWindowClickChangedSlots, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ChangedSlots = []struct { + Location int16 + Item *HashedSlot + }{} + for range lPlayToServerPacketWindowClickChangedSlots { + var PlayToServerPacketWindowClickChangedSlotsElement struct { + Location int16 + Item *HashedSlot + } + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketWindowClickChangedSlotsElement.Location) + if err != nil { + return + } + var PlayToServerPacketWindowClickChangedSlotsElementItemPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketWindowClickChangedSlotsElementItemPresent) + if err != nil { + return + } + if PlayToServerPacketWindowClickChangedSlotsElementItemPresent { + var PlayToServerPacketWindowClickChangedSlotsElementItemPresentValue HashedSlot + err = PlayToServerPacketWindowClickChangedSlotsElementItemPresentValue.Decode(r) + if err != nil { + return + } + PlayToServerPacketWindowClickChangedSlotsElement.Item = &PlayToServerPacketWindowClickChangedSlotsElementItemPresentValue + } + ret.ChangedSlots = append(ret.ChangedSlots, PlayToServerPacketWindowClickChangedSlotsElement) + } + var PlayToServerPacketWindowClickCursorItemPresent bool + err = binary.Read(r, binary.BigEndian, &PlayToServerPacketWindowClickCursorItemPresent) + if err != nil { + return + } + if PlayToServerPacketWindowClickCursorItemPresent { + var PlayToServerPacketWindowClickCursorItemPresentValue HashedSlot + err = PlayToServerPacketWindowClickCursorItemPresentValue.Decode(r) + if err != nil { + return + } + ret.CursorItem = &PlayToServerPacketWindowClickCursorItemPresentValue + } + return +} +func (ret *PlayToServerPacketWindowClick) Encode(w io.Writer) (err error) { + err = ret.WindowId.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.StateId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Slot) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.MouseButton) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Mode) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.ChangedSlots))) + if err != nil { + return + } + for iPlayToServerPacketWindowClickChangedSlots := range len(ret.ChangedSlots) { + err = binary.Write(w, binary.BigEndian, ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Location) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item != nil) + if err != nil { + return + } + if ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item != nil { + err = (*ret.ChangedSlots[iPlayToServerPacketWindowClickChangedSlots].Item).Encode(w) + if err != nil { + return + } + } + } + err = binary.Write(w, binary.BigEndian, ret.CursorItem != nil) + if err != nil { + return + } + if ret.CursorItem != nil { + err = (*ret.CursorItem).Encode(w) + if err != nil { + return + } + } + return +} + +type ArmorTrimMaterial struct { + AssetBase string + OverrideArmorAssets []struct { + Key string + Value string + } + Description nbt.Anon +} + +func (ret *ArmorTrimMaterial) Decode(r io.Reader) (err error) { + ret.AssetBase, err = proto_base.DecodeString(r) + if err != nil { + return + } + var lArmorTrimMaterialOverrideArmorAssets int32 + lArmorTrimMaterialOverrideArmorAssets, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.OverrideArmorAssets = []struct { + Key string + Value string + }{} + for range lArmorTrimMaterialOverrideArmorAssets { + var ArmorTrimMaterialOverrideArmorAssetsElement struct { + Key string + Value string + } + ArmorTrimMaterialOverrideArmorAssetsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + ArmorTrimMaterialOverrideArmorAssetsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.OverrideArmorAssets = append(ret.OverrideArmorAssets, ArmorTrimMaterialOverrideArmorAssetsElement) + } + err = ret.Description.Decode(r) + if err != nil { + return + } + return +} +func (ret *ArmorTrimMaterial) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.AssetBase) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.OverrideArmorAssets))) + if err != nil { + return + } + for iArmorTrimMaterialOverrideArmorAssets := range len(ret.OverrideArmorAssets) { + err = proto_base.EncodeString(w, ret.OverrideArmorAssets[iArmorTrimMaterialOverrideArmorAssets].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.OverrideArmorAssets[iArmorTrimMaterialOverrideArmorAssets].Value) + if err != nil { + return + } + } + err = ret.Description.Encode(w) + if err != nil { + return + } + return +} + +type ArmorTrimPattern struct { + AssetId string + Description nbt.Anon + Decal bool +} + +func (ret *ArmorTrimPattern) Decode(r io.Reader) (err error) { + ret.AssetId, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Description.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Decal) + if err != nil { + return + } + return +} +func (ret *ArmorTrimPattern) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.AssetId) + if err != nil { + return + } + err = ret.Description.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Decal) + if err != nil { + return + } + return +} + +type BannerPattern struct { + AssetId string + TranslationKey string +} + +func (ret *BannerPattern) Decode(r io.Reader) (err error) { + ret.AssetId, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.TranslationKey, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *BannerPattern) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.AssetId) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.TranslationKey) + if err != nil { + return + } + return +} + +type BannerPatternLayer struct { + Pattern any + ColorId int32 +} + +func (ret *BannerPatternLayer) Decode(r io.Reader) (err error) { + var BannerPatternLayerPatternId int32 + BannerPatternLayerPatternId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + if BannerPatternLayerPatternId != 0 { + ret.Pattern = BannerPatternLayerPatternId + } else { + var BannerPatternLayerPatternResult BannerPattern + err = BannerPatternLayerPatternResult.Decode(r) + if err != nil { + return + } + ret.Pattern = BannerPatternLayerPatternResult + } + ret.ColorId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *BannerPatternLayer) Encode(w io.Writer) (err error) { + switch BannerPatternLayerPatternKnownType := ret.Pattern.(type) { + case int32: + err = proto_base.EncodeVarInt(w, BannerPatternLayerPatternKnownType) + if err != nil { + return + } + case BannerPattern: + err = proto_base.EncodeVarInt(w, 0) + if err != nil { + return + } + err = BannerPatternLayerPatternKnownType.Encode(w) + if err != nil { + return + } + default: + err = proto_base.BadTypeError + } + err = proto_base.EncodeVarInt(w, ret.ColorId) + if err != nil { + return + } + return +} + +type ByteArray struct { + Val []byte +} + +func (ret *ByteArray) Decode(r io.Reader) (err error) { + var lByteArray int32 + lByteArray, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Val, err = io.ReadAll(io.LimitReader(r, int64(lByteArray))) + if err != nil { + return + } + return +} +func (ret *ByteArray) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Val))) + if err != nil { + return + } + _, err = w.Write(ret.Val) + if err != nil { + return + } + return +} + +type ContainerID struct { + Val int32 +} + +func (ret *ContainerID) Decode(r io.Reader) (err error) { + ret.Val, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *ContainerID) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Val) + if err != nil { + return + } + return +} + +type DataComponentMatchers struct { + ExactMatchers ExactComponentMatcher + PartialMatchers []int32 +} + +func (ret *DataComponentMatchers) Decode(r io.Reader) (err error) { + err = ret.ExactMatchers.Decode(r) + if err != nil { + return + } + var lDataComponentMatchersPartialMatchers int32 + lDataComponentMatchersPartialMatchers, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.PartialMatchers = []int32{} + for range lDataComponentMatchersPartialMatchers { + var DataComponentMatchersPartialMatchersElement int32 + DataComponentMatchersPartialMatchersElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.PartialMatchers = append(ret.PartialMatchers, DataComponentMatchersPartialMatchersElement) + } + return +} +func (ret *DataComponentMatchers) Encode(w io.Writer) (err error) { + err = ret.ExactMatchers.Encode(w) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.PartialMatchers))) + if err != nil { + return + } + for iDataComponentMatchersPartialMatchers := range len(ret.PartialMatchers) { + err = proto_base.EncodeVarInt(w, ret.PartialMatchers[iDataComponentMatchersPartialMatchers]) + if err != nil { + return + } + } + return +} + +type EntityMetadataPaintingVariant struct { + Width int32 + Height int32 + AssetId string + Title *nbt.Anon + Author *nbt.Anon +} + +func (ret *EntityMetadataPaintingVariant) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Width) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Height) + if err != nil { + return + } + ret.AssetId, err = proto_base.DecodeString(r) + if err != nil { + return + } + var EntityMetadataPaintingVariantTitlePresent bool + err = binary.Read(r, binary.BigEndian, &EntityMetadataPaintingVariantTitlePresent) + if err != nil { + return + } + if EntityMetadataPaintingVariantTitlePresent { + var EntityMetadataPaintingVariantTitlePresentValue nbt.Anon + err = EntityMetadataPaintingVariantTitlePresentValue.Decode(r) + if err != nil { + return + } + ret.Title = &EntityMetadataPaintingVariantTitlePresentValue + } + var EntityMetadataPaintingVariantAuthorPresent bool + err = binary.Read(r, binary.BigEndian, &EntityMetadataPaintingVariantAuthorPresent) + if err != nil { + return + } + if EntityMetadataPaintingVariantAuthorPresent { + var EntityMetadataPaintingVariantAuthorPresentValue nbt.Anon + err = EntityMetadataPaintingVariantAuthorPresentValue.Decode(r) + if err != nil { + return + } + ret.Author = &EntityMetadataPaintingVariantAuthorPresentValue + } + return +} +func (ret *EntityMetadataPaintingVariant) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Width) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Height) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.AssetId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Title != nil) + if err != nil { + return + } + if ret.Title != nil { + err = (*ret.Title).Encode(w) + if err != nil { + return + } + } + err = binary.Write(w, binary.BigEndian, ret.Author != nil) + if err != nil { + return + } + if ret.Author != nil { + err = (*ret.Author).Encode(w) + if err != nil { + return + } + } + return +} + +type ExactComponentMatcher struct { + Val []SlotComponent +} + +func (ret *ExactComponentMatcher) Decode(r io.Reader) (err error) { + var lExactComponentMatcher int32 + lExactComponentMatcher, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Val = []SlotComponent{} + for range lExactComponentMatcher { + var ExactComponentMatcherElement SlotComponent + err = ExactComponentMatcherElement.Decode(r) + if err != nil { + return + } + ret.Val = append(ret.Val, ExactComponentMatcherElement) + } + return +} +func (ret *ExactComponentMatcher) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Val))) + if err != nil { + return + } + for iExactComponentMatcher := range len(ret.Val) { + err = ret.Val[iExactComponentMatcher].Encode(w) + if err != nil { + return + } + } + return +} + +type HashedSlot struct { + ItemId int32 + ItemCount int32 + Components []struct { + Type SlotComponentType + Hash int32 + } + RemoveComponents []struct { + Type SlotComponentType + } +} + +func (ret *HashedSlot) Decode(r io.Reader) (err error) { + ret.ItemId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ItemCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lHashedSlotComponents int32 + lHashedSlotComponents, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Components = []struct { + Type SlotComponentType + Hash int32 + }{} + for range lHashedSlotComponents { + var HashedSlotComponentsElement struct { + Type SlotComponentType + Hash int32 + } + err = HashedSlotComponentsElement.Type.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &HashedSlotComponentsElement.Hash) + if err != nil { + return + } + ret.Components = append(ret.Components, HashedSlotComponentsElement) + } + var lHashedSlotRemoveComponents int32 + lHashedSlotRemoveComponents, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.RemoveComponents = []struct { + Type SlotComponentType + }{} + for range lHashedSlotRemoveComponents { + var HashedSlotRemoveComponentsElement struct { + Type SlotComponentType + } + err = HashedSlotRemoveComponentsElement.Type.Decode(r) + if err != nil { + return + } + ret.RemoveComponents = append(ret.RemoveComponents, HashedSlotRemoveComponentsElement) + } + return +} +func (ret *HashedSlot) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.ItemId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ItemCount) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Components))) + if err != nil { + return + } + for iHashedSlotComponents := range len(ret.Components) { + err = ret.Components[iHashedSlotComponents].Type.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Components[iHashedSlotComponents].Hash) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.RemoveComponents))) + if err != nil { + return + } + for iHashedSlotRemoveComponents := range len(ret.RemoveComponents) { + err = ret.RemoveComponents[iHashedSlotRemoveComponents].Type.Encode(w) + if err != nil { + return + } + } + return +} + +type IDSet struct { + Val any +} + +func (ret *IDSet) Decode(r io.Reader) (err error) { + err = proto_base.ToDoError + return +} +func (ret *IDSet) Encode(w io.Writer) (err error) { + err = proto_base.ToDoError + return +} + +type InstrumentData struct { + SoundEvent ItemSoundHolder + UseDuration float32 + Range float32 + Description nbt.Anon +} + +func (ret *InstrumentData) Decode(r io.Reader) (err error) { + err = ret.SoundEvent.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.UseDuration) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Range) + if err != nil { + return + } + err = ret.Description.Decode(r) + if err != nil { + return + } + return +} +func (ret *InstrumentData) Encode(w io.Writer) (err error) { + err = ret.SoundEvent.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.UseDuration) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Range) + if err != nil { + return + } + err = ret.Description.Encode(w) + if err != nil { + return + } + return +} + +type ItemBlockPredicate struct { + BlockSet *any + Properties *[]ItemBlockProperty + Nbt nbt.Anon + Components DataComponentMatchers +} + +func (ret *ItemBlockPredicate) Decode(r io.Reader) (err error) { + err = proto_base.ToDoError + return +} +func (ret *ItemBlockPredicate) Encode(w io.Writer) (err error) { + err = proto_base.ToDoError + return +} + +type ItemBlockProperty struct { + Name string + IsExactMatch bool + Value any +} + +func (ret *ItemBlockProperty) Decode(r io.Reader) (err error) { + ret.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.IsExactMatch) + if err != nil { + return + } + switch ret.IsExactMatch { + case false: + var ItemBlockPropertyValueFalseTmp struct { + MinValue string + MaxValue string + } + ItemBlockPropertyValueFalseTmp.MinValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + ItemBlockPropertyValueFalseTmp.MaxValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Value = ItemBlockPropertyValueFalseTmp + case true: + var ItemBlockPropertyValueTrueTmp struct { + ExactValue string + } + ItemBlockPropertyValueTrueTmp.ExactValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Value = ItemBlockPropertyValueTrueTmp + } + return +} +func (ret *ItemBlockProperty) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Name) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.IsExactMatch) + if err != nil { + return + } + switch ret.IsExactMatch { + case false: + ItemBlockPropertyValue, ok := ret.Value.(struct { + MinValue string + MaxValue string + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, ItemBlockPropertyValue.MinValue) + if err != nil { + return + } + err = proto_base.EncodeString(w, ItemBlockPropertyValue.MaxValue) + if err != nil { + return + } + case true: + ItemBlockPropertyValue, ok := ret.Value.(struct { + ExactValue string + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, ItemBlockPropertyValue.ExactValue) + if err != nil { + return + } + } + return +} + +type ItemBookPage struct { + Content string + FilteredContent *string +} + +func (ret *ItemBookPage) Decode(r io.Reader) (err error) { + ret.Content, err = proto_base.DecodeString(r) + if err != nil { + return + } + var ItemBookPageFilteredContentPresent bool + err = binary.Read(r, binary.BigEndian, &ItemBookPageFilteredContentPresent) + if err != nil { + return + } + if ItemBookPageFilteredContentPresent { + var ItemBookPageFilteredContentPresentValue string + ItemBookPageFilteredContentPresentValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.FilteredContent = &ItemBookPageFilteredContentPresentValue + } + return +} +func (ret *ItemBookPage) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Content) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.FilteredContent != nil) + if err != nil { + return + } + if ret.FilteredContent != nil { + err = proto_base.EncodeString(w, *ret.FilteredContent) + if err != nil { + return + } + } + return +} + +type ItemConsumeEffect struct { + Type string + Anon any +} + +var ItemConsumeEffectTypeMap = map[int32]string{0: "apply_effects", 1: "remove_effects", 2: "clear_all_effects", 3: "teleport_randomly", 4: "play_sound"} + +func (ret *ItemConsumeEffect) Decode(r io.Reader) (err error) { + var ItemConsumeEffectTypeKey int32 + ItemConsumeEffectTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Type, err = proto_base.ErroringIndex(ItemConsumeEffectTypeMap, ItemConsumeEffectTypeKey) + if err != nil { + return + } + switch ret.Type { + case "apply_effects": + var ItemConsumeEffectAnonApplyEffectsTmp struct { + Effects []ItemPotionEffect + Probability float32 + } + var lItemConsumeEffectAnonEffects int32 + lItemConsumeEffectAnonEffects, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ItemConsumeEffectAnonApplyEffectsTmp.Effects = []ItemPotionEffect{} + for range lItemConsumeEffectAnonEffects { + var ItemConsumeEffectAnonEffectsElement ItemPotionEffect + err = ItemConsumeEffectAnonEffectsElement.Decode(r) + if err != nil { + return + } + ItemConsumeEffectAnonApplyEffectsTmp.Effects = append(ItemConsumeEffectAnonApplyEffectsTmp.Effects, ItemConsumeEffectAnonEffectsElement) + } + err = binary.Read(r, binary.BigEndian, &ItemConsumeEffectAnonApplyEffectsTmp.Probability) + if err != nil { + return + } + ret.Anon = ItemConsumeEffectAnonApplyEffectsTmp + case "clear_all_effects": + var ItemConsumeEffectAnonClearAllEffectsTmp struct { + } + ret.Anon = ItemConsumeEffectAnonClearAllEffectsTmp + case "play_sound": + var ItemConsumeEffectAnonPlaySoundTmp struct { + Sound ItemSoundHolder + } + err = ItemConsumeEffectAnonPlaySoundTmp.Sound.Decode(r) + if err != nil { + return + } + ret.Anon = ItemConsumeEffectAnonPlaySoundTmp + case "remove_effects": + var ItemConsumeEffectAnonRemoveEffectsTmp struct { + Effects IDSet + } + err = ItemConsumeEffectAnonRemoveEffectsTmp.Effects.Decode(r) + if err != nil { + return + } + ret.Anon = ItemConsumeEffectAnonRemoveEffectsTmp + case "teleport_randomly": + var ItemConsumeEffectAnonTeleportRandomlyTmp struct { + Diameter float32 + } + err = binary.Read(r, binary.BigEndian, &ItemConsumeEffectAnonTeleportRandomlyTmp.Diameter) + if err != nil { + return + } + ret.Anon = ItemConsumeEffectAnonTeleportRandomlyTmp + } + return +} + +var ItemConsumeEffectTypeReverseMap = map[string]int32{"apply_effects": 0, "remove_effects": 1, "clear_all_effects": 2, "teleport_randomly": 3, "play_sound": 4} + +func (ret *ItemConsumeEffect) Encode(w io.Writer) (err error) { + var vItemConsumeEffectType int32 + vItemConsumeEffectType, err = proto_base.ErroringIndex(ItemConsumeEffectTypeReverseMap, ret.Type) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vItemConsumeEffectType) + if err != nil { + return + } + switch ret.Type { + case "apply_effects": + ItemConsumeEffectAnon, ok := ret.Anon.(struct { + Effects []ItemPotionEffect + Probability float32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, int32(len(ItemConsumeEffectAnon.Effects))) + if err != nil { + return + } + for iItemConsumeEffectAnonEffects := range len(ItemConsumeEffectAnon.Effects) { + err = ItemConsumeEffectAnon.Effects[iItemConsumeEffectAnonEffects].Encode(w) + if err != nil { + return + } + } + err = binary.Write(w, binary.BigEndian, ItemConsumeEffectAnon.Probability) + if err != nil { + return + } + case "clear_all_effects": + _, ok := ret.Anon.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "play_sound": + ItemConsumeEffectAnon, ok := ret.Anon.(struct { + Sound ItemSoundHolder + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = ItemConsumeEffectAnon.Sound.Encode(w) + if err != nil { + return + } + case "remove_effects": + ItemConsumeEffectAnon, ok := ret.Anon.(struct { + Effects IDSet + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = ItemConsumeEffectAnon.Effects.Encode(w) + if err != nil { + return + } + case "teleport_randomly": + ItemConsumeEffectAnon, ok := ret.Anon.(struct { + Diameter float32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, ItemConsumeEffectAnon.Diameter) + if err != nil { + return + } + } + return +} + +type ItemEffectDetail struct { + Amplifier int32 + Duration int32 + Ambient bool + ShowParticles bool + ShowIcon bool + HiddenEffect *ItemEffectDetail +} + +func (ret *ItemEffectDetail) Decode(r io.Reader) (err error) { + ret.Amplifier, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Duration, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Ambient) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ShowParticles) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ShowIcon) + if err != nil { + return + } + var ItemEffectDetailHiddenEffectPresent bool + err = binary.Read(r, binary.BigEndian, &ItemEffectDetailHiddenEffectPresent) + if err != nil { + return + } + if ItemEffectDetailHiddenEffectPresent { + var ItemEffectDetailHiddenEffectPresentValue ItemEffectDetail + err = ItemEffectDetailHiddenEffectPresentValue.Decode(r) + if err != nil { + return + } + ret.HiddenEffect = &ItemEffectDetailHiddenEffectPresentValue + } + return +} +func (ret *ItemEffectDetail) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Amplifier) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Duration) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Ambient) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ShowParticles) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ShowIcon) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.HiddenEffect != nil) + if err != nil { + return + } + if ret.HiddenEffect != nil { + err = (*ret.HiddenEffect).Encode(w) + if err != nil { + return + } + } + return +} + +type ItemFireworkExplosion struct { + Shape string + Colors []int32 + FadeColors []int32 + HasTrail bool + HasTwinkle bool +} + +var ItemFireworkExplosionShapeMap = map[int32]string{0: "small_ball", 1: "large_ball", 2: "star", 3: "creeper", 4: "burst"} + +func (ret *ItemFireworkExplosion) Decode(r io.Reader) (err error) { + var ItemFireworkExplosionShapeKey int32 + ItemFireworkExplosionShapeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Shape, err = proto_base.ErroringIndex(ItemFireworkExplosionShapeMap, ItemFireworkExplosionShapeKey) + if err != nil { + return + } + var lItemFireworkExplosionColors int32 + lItemFireworkExplosionColors, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Colors = []int32{} + for range lItemFireworkExplosionColors { + var ItemFireworkExplosionColorsElement int32 + err = binary.Read(r, binary.BigEndian, &ItemFireworkExplosionColorsElement) + if err != nil { + return + } + ret.Colors = append(ret.Colors, ItemFireworkExplosionColorsElement) + } + var lItemFireworkExplosionFadeColors int32 + lItemFireworkExplosionFadeColors, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.FadeColors = []int32{} + for range lItemFireworkExplosionFadeColors { + var ItemFireworkExplosionFadeColorsElement int32 + err = binary.Read(r, binary.BigEndian, &ItemFireworkExplosionFadeColorsElement) + if err != nil { + return + } + ret.FadeColors = append(ret.FadeColors, ItemFireworkExplosionFadeColorsElement) + } + err = binary.Read(r, binary.BigEndian, &ret.HasTrail) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.HasTwinkle) + if err != nil { + return + } + return +} + +var ItemFireworkExplosionShapeReverseMap = map[string]int32{"small_ball": 0, "large_ball": 1, "star": 2, "creeper": 3, "burst": 4} + +func (ret *ItemFireworkExplosion) Encode(w io.Writer) (err error) { + var vItemFireworkExplosionShape int32 + vItemFireworkExplosionShape, err = proto_base.ErroringIndex(ItemFireworkExplosionShapeReverseMap, ret.Shape) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vItemFireworkExplosionShape) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Colors))) + if err != nil { + return + } + for iItemFireworkExplosionColors := range len(ret.Colors) { + err = binary.Write(w, binary.BigEndian, ret.Colors[iItemFireworkExplosionColors]) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, int32(len(ret.FadeColors))) + if err != nil { + return + } + for iItemFireworkExplosionFadeColors := range len(ret.FadeColors) { + err = binary.Write(w, binary.BigEndian, ret.FadeColors[iItemFireworkExplosionFadeColors]) + if err != nil { + return + } + } + err = binary.Write(w, binary.BigEndian, ret.HasTrail) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.HasTwinkle) + if err != nil { + return + } + return +} + +type ItemPotionEffect struct { + Id int32 + Details ItemEffectDetail +} + +func (ret *ItemPotionEffect) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.Details.Decode(r) + if err != nil { + return + } + return +} +func (ret *ItemPotionEffect) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Id) + if err != nil { + return + } + err = ret.Details.Encode(w) + if err != nil { + return + } + return +} + +type ItemSoundEvent struct { + SoundName string + FixedRange *float32 +} + +func (ret *ItemSoundEvent) Decode(r io.Reader) (err error) { + ret.SoundName, err = proto_base.DecodeString(r) + if err != nil { + return + } + var ItemSoundEventFixedRangePresent bool + err = binary.Read(r, binary.BigEndian, &ItemSoundEventFixedRangePresent) + if err != nil { + return + } + if ItemSoundEventFixedRangePresent { + var ItemSoundEventFixedRangePresentValue float32 + err = binary.Read(r, binary.BigEndian, &ItemSoundEventFixedRangePresentValue) + if err != nil { + return + } + ret.FixedRange = &ItemSoundEventFixedRangePresentValue + } + return +} +func (ret *ItemSoundEvent) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.SoundName) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.FixedRange != nil) + if err != nil { + return + } + if ret.FixedRange != nil { + err = binary.Write(w, binary.BigEndian, *ret.FixedRange) + if err != nil { + return + } + } + return +} + +type ItemSoundHolder struct { + Val any +} + +func (ret *ItemSoundHolder) Decode(r io.Reader) (err error) { + var ItemSoundHolderId int32 + ItemSoundHolderId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + if ItemSoundHolderId != 0 { + ret.Val = ItemSoundHolderId + } else { + var ItemSoundHolderResult ItemSoundEvent + err = ItemSoundHolderResult.Decode(r) + if err != nil { + return + } + ret.Val = ItemSoundHolderResult + } + return +} +func (ret *ItemSoundHolder) Encode(w io.Writer) (err error) { + switch ItemSoundHolderKnownType := ret.Val.(type) { + case int32: + err = proto_base.EncodeVarInt(w, ItemSoundHolderKnownType) + if err != nil { + return + } + case ItemSoundEvent: + err = proto_base.EncodeVarInt(w, 0) + if err != nil { + return + } + err = ItemSoundHolderKnownType.Encode(w) + if err != nil { + return + } + default: + err = proto_base.BadTypeError + } + return +} + +type ItemWrittenBookPage struct { + Content nbt.Anon + FilteredContent nbt.Anon +} + +func (ret *ItemWrittenBookPage) Decode(r io.Reader) (err error) { + err = ret.Content.Decode(r) + if err != nil { + return + } + err = ret.FilteredContent.Decode(r) + if err != nil { + return + } + return +} +func (ret *ItemWrittenBookPage) Encode(w io.Writer) (err error) { + err = ret.Content.Encode(w) + if err != nil { + return + } + err = ret.FilteredContent.Encode(w) + if err != nil { + return + } + return +} + +type JukeboxSongData struct { + SoundEvent ItemSoundHolder + Description nbt.Anon + LengthInSeconds float32 + ComparatorOutput int32 +} + +func (ret *JukeboxSongData) Decode(r io.Reader) (err error) { + err = ret.SoundEvent.Decode(r) + if err != nil { + return + } + err = ret.Description.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.LengthInSeconds) + if err != nil { + return + } + ret.ComparatorOutput, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *JukeboxSongData) Encode(w io.Writer) (err error) { + err = ret.SoundEvent.Encode(w) + if err != nil { + return + } + err = ret.Description.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.LengthInSeconds) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ComparatorOutput) + if err != nil { + return + } + return +} + +type Particle struct { + Type string + Data any +} + +var ParticleTypeMap = map[int32]string{0: "angry_villager", 1: "block", 10: "landing_lava", 100: "electric_spark", 101: "scrape", 102: "shriek", 103: "egg_crack", 104: "dust_plume", 105: "trial_spawner_detected_player", 106: "trial_spawner_detected_player_ominous", 107: "vault_connection", 108: "dust_pillar", 109: "ominous_spawning", 11: "dripping_water", 110: "raid_omen", 111: "trial_omen", 112: "block_crumble", 113: "firefly", 12: "falling_water", 13: "dust", 14: "dust_color_transition", 15: "effect", 16: "elder_guardian", 17: "enchanted_hit", 18: "enchant", 19: "end_rod", 2: "block_marker", 20: "entity_effect", 21: "explosion_emitter", 22: "explosion", 23: "gust", 24: "small_gust", 25: "gust_emitter_large", 26: "gust_emitter_small", 27: "sonic_boom", 28: "falling_dust", 29: "firework", 3: "bubble", 30: "fishing", 31: "flame", 32: "infested", 33: "cherry_leaves", 34: "pale_oak_leaves", 35: "tinted_leaves", 36: "sculk_soul", 37: "sculk_charge", 38: "sculk_charge_pop", 39: "soul_fire_flame", 4: "cloud", 40: "soul", 41: "flash", 42: "happy_villager", 43: "composter", 44: "heart", 45: "instant_effect", 46: "item", 47: "vibration", 48: "trail", 49: "item_slime", 5: "crit", 50: "item_cobweb", 51: "item_snowball", 52: "large_smoke", 53: "lava", 54: "mycelium", 55: "note", 56: "poof", 57: "portal", 58: "rain", 59: "smoke", 6: "damage_indicator", 60: "white_smoke", 61: "sneeze", 62: "spit", 63: "squid_ink", 64: "sweep_attack", 65: "totem_of_undying", 66: "underwater", 67: "splash", 68: "witch", 69: "bubble_pop", 7: "dragon_breath", 70: "current_down", 71: "bubble_column_up", 72: "nautilus", 73: "dolphin", 74: "campfire_cosy_smoke", 75: "campfire_signal_smoke", 76: "dripping_honey", 77: "falling_honey", 78: "landing_honey", 79: "falling_nectar", 8: "dripping_lava", 80: "falling_spore_blossom", 81: "ash", 82: "crimson_spore", 83: "warped_spore", 84: "spore_blossom_air", 85: "dripping_obsidian_tear", 86: "falling_obsidian_tear", 87: "landing_obsidian_tear", 88: "reverse_portal", 89: "white_ash", 9: "falling_lava", 90: "small_flame", 91: "snowflake", 92: "dripping_dripstone_lava", 93: "falling_dripstone_lava", 94: "dripping_dripstone_water", 95: "falling_dripstone_water", 96: "glow_squid_ink", 97: "glow", 98: "wax_on", 99: "wax_off"} +var ParticleDataPositionTypeMap = map[int32]string{0: "block", 1: "entity"} + +func (ret *Particle) Decode(r io.Reader) (err error) { + var ParticleTypeKey int32 + ParticleTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Type, err = proto_base.ErroringIndex(ParticleTypeMap, ParticleTypeKey) + if err != nil { + return + } + switch ret.Type { + case "block": + var ParticleDataBlockTmp int32 + ParticleDataBlockTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Data = ParticleDataBlockTmp + case "block_crumble": + var ParticleDataBlockCrumbleTmp int32 + ParticleDataBlockCrumbleTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Data = ParticleDataBlockCrumbleTmp + case "block_marker": + var ParticleDataBlockMarkerTmp int32 + ParticleDataBlockMarkerTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Data = ParticleDataBlockMarkerTmp + case "dust": + var ParticleDataDustTmp struct { + Red float32 + Green float32 + Blue float32 + Scale float32 + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Red) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Green) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Blue) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustTmp.Scale) + if err != nil { + return + } + ret.Data = ParticleDataDustTmp + case "dust_color_transition": + var ParticleDataDustColorTransitionTmp struct { + FromRed float32 + FromGreen float32 + FromBlue float32 + Scale float32 + ToRed float32 + ToGreen float32 + ToBlue float32 + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromRed) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromGreen) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.FromBlue) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.Scale) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToRed) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToGreen) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataDustColorTransitionTmp.ToBlue) + if err != nil { + return + } + ret.Data = ParticleDataDustColorTransitionTmp + case "dust_pillar": + var ParticleDataDustPillarTmp int32 + ParticleDataDustPillarTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Data = ParticleDataDustPillarTmp + case "entity_effect": + var ParticleDataEntityEffectTmp int32 + err = binary.Read(r, binary.BigEndian, &ParticleDataEntityEffectTmp) + if err != nil { + return + } + ret.Data = ParticleDataEntityEffectTmp + case "falling_dust": + var ParticleDataFallingDustTmp int32 + ParticleDataFallingDustTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Data = ParticleDataFallingDustTmp + case "firefly": + var ParticleDataFireflyTmp struct { + } + ret.Data = ParticleDataFireflyTmp + case "item": + var ParticleDataItemTmp Slot + err = ParticleDataItemTmp.Decode(r) + if err != nil { + return + } + ret.Data = ParticleDataItemTmp + case "sculk_charge": + var ParticleDataSculkChargeTmp float32 + err = binary.Read(r, binary.BigEndian, &ParticleDataSculkChargeTmp) + if err != nil { + return + } + ret.Data = ParticleDataSculkChargeTmp + case "shriek": + var ParticleDataShriekTmp int32 + ParticleDataShriekTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Data = ParticleDataShriekTmp + case "tinted_leaves": + var ParticleDataTintedLeavesTmp int32 + err = binary.Read(r, binary.BigEndian, &ParticleDataTintedLeavesTmp) + if err != nil { + return + } + ret.Data = ParticleDataTintedLeavesTmp + case "trail": + var ParticleDataTrailTmp struct { + Target Vec3f64 + Color uint8 + } + err = ParticleDataTrailTmp.Target.Decode(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataTrailTmp.Color) + if err != nil { + return + } + ret.Data = ParticleDataTrailTmp + case "vibration": + var ParticleDataVibrationTmp struct { + PositionType string + Position any + Ticks int32 + } + var ParticleDataPositionTypeKey int32 + ParticleDataPositionTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ParticleDataVibrationTmp.PositionType, err = proto_base.ErroringIndex(ParticleDataPositionTypeMap, ParticleDataPositionTypeKey) + if err != nil { + return + } + switch ParticleDataVibrationTmp.PositionType { + case "block": + var ParticleDataPositionBlockTmp Position + err = ParticleDataPositionBlockTmp.Decode(r) + if err != nil { + return + } + ParticleDataVibrationTmp.Position = ParticleDataPositionBlockTmp + case "entity": + var ParticleDataPositionEntityTmp struct { + EntityId int32 + EntityEyeHeight float32 + } + ParticleDataPositionEntityTmp.EntityId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ParticleDataPositionEntityTmp.EntityEyeHeight) + if err != nil { + return + } + ParticleDataVibrationTmp.Position = ParticleDataPositionEntityTmp + } + ParticleDataVibrationTmp.Ticks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Data = ParticleDataVibrationTmp + } + return +} + +var ParticleTypeReverseMap = map[string]int32{"angry_villager": 0, "block": 1, "landing_lava": 10, "electric_spark": 100, "scrape": 101, "shriek": 102, "egg_crack": 103, "dust_plume": 104, "trial_spawner_detected_player": 105, "trial_spawner_detected_player_ominous": 106, "vault_connection": 107, "dust_pillar": 108, "ominous_spawning": 109, "dripping_water": 11, "raid_omen": 110, "trial_omen": 111, "block_crumble": 112, "firefly": 113, "falling_water": 12, "dust": 13, "dust_color_transition": 14, "effect": 15, "elder_guardian": 16, "enchanted_hit": 17, "enchant": 18, "end_rod": 19, "block_marker": 2, "entity_effect": 20, "explosion_emitter": 21, "explosion": 22, "gust": 23, "small_gust": 24, "gust_emitter_large": 25, "gust_emitter_small": 26, "sonic_boom": 27, "falling_dust": 28, "firework": 29, "bubble": 3, "fishing": 30, "flame": 31, "infested": 32, "cherry_leaves": 33, "pale_oak_leaves": 34, "tinted_leaves": 35, "sculk_soul": 36, "sculk_charge": 37, "sculk_charge_pop": 38, "soul_fire_flame": 39, "cloud": 4, "soul": 40, "flash": 41, "happy_villager": 42, "composter": 43, "heart": 44, "instant_effect": 45, "item": 46, "vibration": 47, "trail": 48, "item_slime": 49, "crit": 5, "item_cobweb": 50, "item_snowball": 51, "large_smoke": 52, "lava": 53, "mycelium": 54, "note": 55, "poof": 56, "portal": 57, "rain": 58, "smoke": 59, "damage_indicator": 6, "white_smoke": 60, "sneeze": 61, "spit": 62, "squid_ink": 63, "sweep_attack": 64, "totem_of_undying": 65, "underwater": 66, "splash": 67, "witch": 68, "bubble_pop": 69, "dragon_breath": 7, "current_down": 70, "bubble_column_up": 71, "nautilus": 72, "dolphin": 73, "campfire_cosy_smoke": 74, "campfire_signal_smoke": 75, "dripping_honey": 76, "falling_honey": 77, "landing_honey": 78, "falling_nectar": 79, "dripping_lava": 8, "falling_spore_blossom": 80, "ash": 81, "crimson_spore": 82, "warped_spore": 83, "spore_blossom_air": 84, "dripping_obsidian_tear": 85, "falling_obsidian_tear": 86, "landing_obsidian_tear": 87, "reverse_portal": 88, "white_ash": 89, "falling_lava": 9, "small_flame": 90, "snowflake": 91, "dripping_dripstone_lava": 92, "falling_dripstone_lava": 93, "dripping_dripstone_water": 94, "falling_dripstone_water": 95, "glow_squid_ink": 96, "glow": 97, "wax_on": 98, "wax_off": 99} +var ParticleDataPositionTypeReverseMap = map[string]int32{"block": 0, "entity": 1} + +func (ret *Particle) Encode(w io.Writer) (err error) { + var vParticleType int32 + vParticleType, err = proto_base.ErroringIndex(ParticleTypeReverseMap, ret.Type) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vParticleType) + if err != nil { + return + } + switch ret.Type { + case "block": + ParticleData, ok := ret.Data.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, ParticleData) + if err != nil { + return + } + case "block_crumble": + ParticleData, ok := ret.Data.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, ParticleData) + if err != nil { + return + } + case "block_marker": + ParticleData, ok := ret.Data.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, ParticleData) + if err != nil { + return + } + case "dust": + ParticleData, ok := ret.Data.(struct { + Red float32 + Green float32 + Blue float32 + Scale float32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.Red) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.Green) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.Blue) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.Scale) + if err != nil { + return + } + case "dust_color_transition": + ParticleData, ok := ret.Data.(struct { + FromRed float32 + FromGreen float32 + FromBlue float32 + Scale float32 + ToRed float32 + ToGreen float32 + ToBlue float32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.FromRed) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.FromGreen) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.FromBlue) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.Scale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.ToRed) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.ToGreen) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.ToBlue) + if err != nil { + return + } + case "dust_pillar": + ParticleData, ok := ret.Data.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, ParticleData) + if err != nil { + return + } + case "entity_effect": + ParticleData, ok := ret.Data.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, ParticleData) + if err != nil { + return + } + case "falling_dust": + ParticleData, ok := ret.Data.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, ParticleData) + if err != nil { + return + } + case "firefly": + _, ok := ret.Data.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "item": + ParticleData, ok := ret.Data.(Slot) + if !ok { + err = proto_base.BadTypeError + return + } + err = ParticleData.Encode(w) + if err != nil { + return + } + case "sculk_charge": + ParticleData, ok := ret.Data.(float32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, ParticleData) + if err != nil { + return + } + case "shriek": + ParticleData, ok := ret.Data.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, ParticleData) + if err != nil { + return + } + case "tinted_leaves": + ParticleData, ok := ret.Data.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, ParticleData) + if err != nil { + return + } + case "trail": + ParticleData, ok := ret.Data.(struct { + Target Vec3f64 + Color uint8 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = ParticleData.Target.Encode(w) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleData.Color) + if err != nil { + return + } + case "vibration": + ParticleData, ok := ret.Data.(struct { + PositionType string + Position any + Ticks int32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + var vParticleDataPositionType int32 + vParticleDataPositionType, err = proto_base.ErroringIndex(ParticleDataPositionTypeReverseMap, ParticleData.PositionType) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vParticleDataPositionType) + if err != nil { + return + } + switch ParticleData.PositionType { + case "block": + ParticleDataPosition, ok := ParticleData.Position.(Position) + if !ok { + err = proto_base.BadTypeError + return + } + err = ParticleDataPosition.Encode(w) + if err != nil { + return + } + case "entity": + ParticleDataPosition, ok := ParticleData.Position.(struct { + EntityId int32 + EntityEyeHeight float32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, ParticleDataPosition.EntityId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ParticleDataPosition.EntityEyeHeight) + if err != nil { + return + } + } + err = proto_base.EncodeVarInt(w, ParticleData.Ticks) + if err != nil { + return + } + } + return +} + +type ServerLinkType struct { + Val string +} + +var ServerLinkTypeMap = map[int32]string{0: "bug_report", 1: "community_guidelines", 2: "support", 3: "status", 4: "feedback", 5: "community", 6: "website", 7: "forums", 8: "news", 9: "announcements"} + +func (ret *ServerLinkType) Decode(r io.Reader) (err error) { + var ServerLinkTypeKey int32 + ServerLinkTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Val, err = proto_base.ErroringIndex(ServerLinkTypeMap, ServerLinkTypeKey) + if err != nil { + return + } + return +} + +var ServerLinkTypeReverseMap = map[string]int32{"bug_report": 0, "community_guidelines": 1, "support": 2, "status": 3, "feedback": 4, "community": 5, "website": 6, "forums": 7, "news": 8, "announcements": 9} + +func (ret *ServerLinkType) Encode(w io.Writer) (err error) { + var vServerLinkType int32 + vServerLinkType, err = proto_base.ErroringIndex(ServerLinkTypeReverseMap, ret.Val) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vServerLinkType) + if err != nil { + return + } + return +} + +type Slot struct { + ItemCount int32 + Anon any +} + +func (ret *Slot) Decode(r io.Reader) (err error) { + ret.ItemCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + switch ret.ItemCount { + case 0: + var SlotAnon0Tmp struct { + } + ret.Anon = SlotAnon0Tmp + default: + var SlotAnonTmp struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []SlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + } + SlotAnonTmp.ItemId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + SlotAnonTmp.AddedComponentCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + SlotAnonTmp.RemovedComponentCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lSlotAnonComponents int32 + lSlotAnonComponents = SlotAnonTmp.AddedComponentCount + SlotAnonTmp.Components = []SlotComponent{} + for range lSlotAnonComponents { + var SlotAnonComponentsElement SlotComponent + err = SlotAnonComponentsElement.Decode(r) + if err != nil { + return + } + SlotAnonTmp.Components = append(SlotAnonTmp.Components, SlotAnonComponentsElement) + } + var lSlotAnonRemoveComponents int32 + lSlotAnonRemoveComponents = SlotAnonTmp.RemovedComponentCount + SlotAnonTmp.RemoveComponents = []struct { + Type SlotComponentType + }{} + for range lSlotAnonRemoveComponents { + var SlotAnonRemoveComponentsElement struct { + Type SlotComponentType + } + err = SlotAnonRemoveComponentsElement.Type.Decode(r) + if err != nil { + return + } + SlotAnonTmp.RemoveComponents = append(SlotAnonTmp.RemoveComponents, SlotAnonRemoveComponentsElement) + } + ret.Anon = SlotAnonTmp + } + return +} +func (ret *Slot) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.ItemCount) + if err != nil { + return + } + switch ret.ItemCount { + case 0: + _, ok := ret.Anon.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + default: + _, ok := ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []SlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []SlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).ItemId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []SlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).AddedComponentCount) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []SlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).RemovedComponentCount) + if err != nil { + return + } + for iSlotAnonComponents := range len(ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []SlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).Components) { + err = ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []SlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).Components[iSlotAnonComponents].Encode(w) + if err != nil { + return + } + } + for iSlotAnonRemoveComponents := range len(ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []SlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).RemoveComponents) { + err = ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []SlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).RemoveComponents[iSlotAnonRemoveComponents].Type.Encode(w) + if err != nil { + return + } + } + } + return +} + +type SlotComponent struct { + Type SlotComponentType + Data any +} + +func (ret *SlotComponent) Decode(r io.Reader) (err error) { + err = proto_base.ToDoError + return +} +func (ret *SlotComponent) Encode(w io.Writer) (err error) { + err = proto_base.ToDoError + return +} + +type SlotComponentType struct { + Val string +} + +var SlotComponentTypeMap = map[int32]string{0: "custom_data", 1: "max_stack_size", 10: "enchantments", 11: "can_place_on", 12: "can_break", 13: "attribute_modifiers", 14: "custom_model_data", 15: "tooltip_display", 16: "repair_cost", 17: "creative_slot_lock", 18: "enchantment_glint_override", 19: "intangible_projectile", 2: "max_damage", 20: "food", 21: "consumable", 22: "use_remainder", 23: "use_cooldown", 24: "damage_resistant", 25: "tool", 26: "weapon", 27: "enchantable", 28: "equippable", 29: "repairable", 3: "damage", 30: "glider", 31: "tooltip_style", 32: "death_protection", 33: "blocks_attacks", 34: "stored_enchantments", 35: "dyed_color", 36: "map_color", 37: "map_id", 38: "map_decorations", 39: "map_post_processing", 4: "unbreakable", 40: "potion_duration_scale", 41: "charged_projectiles", 42: "bundle_contents", 43: "potion_contents", 44: "suspicious_stew_effects", 45: "writable_book_content", 46: "written_book_content", 47: "trim", 48: "debug_stick_state", 49: "entity_data", 5: "custom_name", 50: "bucket_entity_data", 51: "block_entity_data", 52: "instrument", 53: "provides_trim_material", 54: "ominous_bottle_amplifier", 55: "jukebox_playable", 56: "provides_banner_patterns", 57: "recipes", 58: "lodestone_tracker", 59: "firework_explosion", 6: "item_name", 60: "fireworks", 61: "profile", 62: "note_block_sound", 63: "banner_patterns", 64: "base_color", 65: "pot_decorations", 66: "container", 67: "block_state", 68: "bees", 69: "lock", 7: "item_model", 70: "container_loot", 71: "break_sound", 72: "villager/variant", 73: "wolf/variant", 74: "wolf/sound_variant", 75: "wolf/collar", 76: "fox/variant", 77: "salmon/size", 78: "parrot/variant", 79: "tropical_fish/pattern", 8: "lore", 80: "tropical_fish/base_color", 81: "tropical_fish/pattern_color", 82: "mooshroom/variant", 83: "rabbit/variant", 84: "pig/variant", 85: "cow/variant", 86: "chicken/variant", 87: "frog/variant", 88: "horse/variant", 89: "painting/variant", 9: "rarity", 90: "llama/variant", 91: "axolotl/variant", 92: "cat/variant", 93: "cat/collar", 94: "sheep/color", 95: "shulker/color"} + +func (ret *SlotComponentType) Decode(r io.Reader) (err error) { + var SlotComponentTypeKey int32 + SlotComponentTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Val, err = proto_base.ErroringIndex(SlotComponentTypeMap, SlotComponentTypeKey) + if err != nil { + return + } + return +} + +var SlotComponentTypeReverseMap = map[string]int32{"custom_data": 0, "max_stack_size": 1, "enchantments": 10, "can_place_on": 11, "can_break": 12, "attribute_modifiers": 13, "custom_model_data": 14, "tooltip_display": 15, "repair_cost": 16, "creative_slot_lock": 17, "enchantment_glint_override": 18, "intangible_projectile": 19, "max_damage": 2, "food": 20, "consumable": 21, "use_remainder": 22, "use_cooldown": 23, "damage_resistant": 24, "tool": 25, "weapon": 26, "enchantable": 27, "equippable": 28, "repairable": 29, "damage": 3, "glider": 30, "tooltip_style": 31, "death_protection": 32, "blocks_attacks": 33, "stored_enchantments": 34, "dyed_color": 35, "map_color": 36, "map_id": 37, "map_decorations": 38, "map_post_processing": 39, "unbreakable": 4, "potion_duration_scale": 40, "charged_projectiles": 41, "bundle_contents": 42, "potion_contents": 43, "suspicious_stew_effects": 44, "writable_book_content": 45, "written_book_content": 46, "trim": 47, "debug_stick_state": 48, "entity_data": 49, "custom_name": 5, "bucket_entity_data": 50, "block_entity_data": 51, "instrument": 52, "provides_trim_material": 53, "ominous_bottle_amplifier": 54, "jukebox_playable": 55, "provides_banner_patterns": 56, "recipes": 57, "lodestone_tracker": 58, "firework_explosion": 59, "item_name": 6, "fireworks": 60, "profile": 61, "note_block_sound": 62, "banner_patterns": 63, "base_color": 64, "pot_decorations": 65, "container": 66, "block_state": 67, "bees": 68, "lock": 69, "item_model": 7, "container_loot": 70, "break_sound": 71, "villager/variant": 72, "wolf/variant": 73, "wolf/sound_variant": 74, "wolf/collar": 75, "fox/variant": 76, "salmon/size": 77, "parrot/variant": 78, "tropical_fish/pattern": 79, "lore": 8, "tropical_fish/base_color": 80, "tropical_fish/pattern_color": 81, "mooshroom/variant": 82, "rabbit/variant": 83, "pig/variant": 84, "cow/variant": 85, "chicken/variant": 86, "frog/variant": 87, "horse/variant": 88, "painting/variant": 89, "rarity": 9, "llama/variant": 90, "axolotl/variant": 91, "cat/variant": 92, "cat/collar": 93, "sheep/color": 94, "shulker/color": 95} + +func (ret *SlotComponentType) Encode(w io.Writer) (err error) { + var vSlotComponentType int32 + vSlotComponentType, err = proto_base.ErroringIndex(SlotComponentTypeReverseMap, ret.Val) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vSlotComponentType) + if err != nil { + return + } + return +} + +type UntrustedSlot struct { + ItemCount int32 + Anon any +} + +func (ret *UntrustedSlot) Decode(r io.Reader) (err error) { + ret.ItemCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + switch ret.ItemCount { + case 0: + var UntrustedSlotAnon0Tmp struct { + } + ret.Anon = UntrustedSlotAnon0Tmp + default: + var UntrustedSlotAnonTmp struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []UntrustedSlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + } + UntrustedSlotAnonTmp.ItemId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + UntrustedSlotAnonTmp.AddedComponentCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + UntrustedSlotAnonTmp.RemovedComponentCount, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var lUntrustedSlotAnonComponents int32 + lUntrustedSlotAnonComponents = UntrustedSlotAnonTmp.AddedComponentCount + UntrustedSlotAnonTmp.Components = []UntrustedSlotComponent{} + for range lUntrustedSlotAnonComponents { + var UntrustedSlotAnonComponentsElement UntrustedSlotComponent + err = UntrustedSlotAnonComponentsElement.Decode(r) + if err != nil { + return + } + UntrustedSlotAnonTmp.Components = append(UntrustedSlotAnonTmp.Components, UntrustedSlotAnonComponentsElement) + } + var lUntrustedSlotAnonRemoveComponents int32 + lUntrustedSlotAnonRemoveComponents = UntrustedSlotAnonTmp.RemovedComponentCount + UntrustedSlotAnonTmp.RemoveComponents = []struct { + Type SlotComponentType + }{} + for range lUntrustedSlotAnonRemoveComponents { + var UntrustedSlotAnonRemoveComponentsElement struct { + Type SlotComponentType + } + err = UntrustedSlotAnonRemoveComponentsElement.Type.Decode(r) + if err != nil { + return + } + UntrustedSlotAnonTmp.RemoveComponents = append(UntrustedSlotAnonTmp.RemoveComponents, UntrustedSlotAnonRemoveComponentsElement) + } + ret.Anon = UntrustedSlotAnonTmp + } + return +} +func (ret *UntrustedSlot) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.ItemCount) + if err != nil { + return + } + switch ret.ItemCount { + case 0: + _, ok := ret.Anon.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + default: + _, ok := ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []UntrustedSlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []UntrustedSlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).ItemId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []UntrustedSlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).AddedComponentCount) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []UntrustedSlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).RemovedComponentCount) + if err != nil { + return + } + for iUntrustedSlotAnonComponents := range len(ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []UntrustedSlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).Components) { + err = ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []UntrustedSlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).Components[iUntrustedSlotAnonComponents].Encode(w) + if err != nil { + return + } + } + for iUntrustedSlotAnonRemoveComponents := range len(ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []UntrustedSlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).RemoveComponents) { + err = ret.Anon.(struct { + ItemId int32 + AddedComponentCount int32 + RemovedComponentCount int32 + Components []UntrustedSlotComponent + RemoveComponents []struct { + Type SlotComponentType + } + }).RemoveComponents[iUntrustedSlotAnonRemoveComponents].Type.Encode(w) + if err != nil { + return + } + } + } + return +} + +type UntrustedSlotComponent struct { + Type SlotComponentType + Data ByteArray +} + +func (ret *UntrustedSlotComponent) Decode(r io.Reader) (err error) { + err = ret.Type.Decode(r) + if err != nil { + return + } + err = ret.Data.Decode(r) + if err != nil { + return + } + return +} +func (ret *UntrustedSlotComponent) Encode(w io.Writer) (err error) { + err = ret.Type.Encode(w) + if err != nil { + return + } + err = ret.Data.Encode(w) + if err != nil { + return + } + return +} + +type ChatSession struct { + Val *struct { + Uuid uuid.UUID + PublicKey struct { + ExpireTime int64 + KeyBytes []byte + KeySignature []byte + } + } +} + +func (ret *ChatSession) Decode(r io.Reader) (err error) { + var ChatSessionPresent bool + err = binary.Read(r, binary.BigEndian, &ChatSessionPresent) + if err != nil { + return + } + if ChatSessionPresent { + var ChatSessionPresentValue struct { + Uuid uuid.UUID + PublicKey struct { + ExpireTime int64 + KeyBytes []byte + KeySignature []byte + } + } + _, err = io.ReadFull(r, ChatSessionPresentValue.Uuid[:]) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ChatSessionPresentValue.PublicKey.ExpireTime) + if err != nil { + return + } + var lChatSessionPublicKeyKeyBytes int32 + lChatSessionPublicKeyKeyBytes, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ChatSessionPresentValue.PublicKey.KeyBytes, err = io.ReadAll(io.LimitReader(r, int64(lChatSessionPublicKeyKeyBytes))) + if err != nil { + return + } + var lChatSessionPublicKeyKeySignature int32 + lChatSessionPublicKeyKeySignature, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ChatSessionPresentValue.PublicKey.KeySignature, err = io.ReadAll(io.LimitReader(r, int64(lChatSessionPublicKeyKeySignature))) + if err != nil { + return + } + ret.Val = &ChatSessionPresentValue + } + return +} +func (ret *ChatSession) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Val != nil) + if err != nil { + return + } + if ret.Val != nil { + _, err = w.Write((*ret.Val).Uuid[:]) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, (*ret.Val).PublicKey.ExpireTime) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len((*ret.Val).PublicKey.KeyBytes))) + if err != nil { + return + } + _, err = w.Write((*ret.Val).PublicKey.KeyBytes) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len((*ret.Val).PublicKey.KeySignature))) + if err != nil { + return + } + _, err = w.Write((*ret.Val).PublicKey.KeySignature) + if err != nil { + return + } + } + return +} + +type ChunkBlockEntity struct { + Anon uint8 + Y int16 + Type int32 + NbtData nbt.Anon +} + +func (ret *ChunkBlockEntity) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Anon) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + ret.Type, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = ret.NbtData.Decode(r) + if err != nil { + return + } + return +} +func (ret *ChunkBlockEntity) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Anon) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Type) + if err != nil { + return + } + err = ret.NbtData.Encode(w) + if err != nil { + return + } + return +} + +type CommandNode struct { + Flags uint8 + Children []int32 + RedirectNode any + ExtraNodeData any +} + +var CommandNodeExtraNodeDataParserMap = map[int32]string{0: "brigadier:bool", 1: "brigadier:float", 10: "minecraft:vec3", 11: "minecraft:vec2", 12: "minecraft:block_state", 13: "minecraft:block_predicate", 14: "minecraft:item_stack", 15: "minecraft:item_predicate", 16: "minecraft:color", 17: "minecraft:hex_color", 18: "minecraft:component", 19: "minecraft:style", 2: "brigadier:double", 20: "minecraft:message", 21: "minecraft:nbt", 22: "minecraft:nbt_tag", 23: "minecraft:nbt_path", 24: "minecraft:objective", 25: "minecraft:objective_criteria", 26: "minecraft:operation", 27: "minecraft:particle", 28: "minecraft:angle", 29: "minecraft:rotation", 3: "brigadier:integer", 30: "minecraft:scoreboard_slot", 31: "minecraft:score_holder", 32: "minecraft:swizzle", 33: "minecraft:team", 34: "minecraft:item_slot", 35: "minecraft:item_slots", 36: "minecraft:resource_location", 37: "minecraft:function", 38: "minecraft:entity_anchor", 39: "minecraft:int_range", 4: "brigadier:long", 40: "minecraft:float_range", 41: "minecraft:dimension", 42: "minecraft:gamemode", 43: "minecraft:time", 44: "minecraft:resource_or_tag", 45: "minecraft:resource_or_tag_key", 46: "minecraft:resource", 47: "minecraft:resource_key", 48: "minecraft:resource_selector", 49: "minecraft:template_mirror", 5: "brigadier:string", 50: "minecraft:template_rotation", 51: "minecraft:heightmap", 52: "minecraft:loot_table", 53: "minecraft:loot_predicate", 54: "minecraft:loot_modifier", 55: "minecraft:dialog", 56: "minecraft:uuid", 6: "minecraft:entity", 7: "minecraft:game_profile", 8: "minecraft:block_pos", 9: "minecraft:column_pos"} +var CommandNodeExtraNodeDataPropertiesMap = map[int32]string{0: "SINGLE_WORD", 1: "QUOTABLE_PHRASE", 2: "GREEDY_PHRASE"} + +func (ret *CommandNode) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Flags) + if err != nil { + return + } + var lCommandNodeChildren int32 + lCommandNodeChildren, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Children = []int32{} + for range lCommandNodeChildren { + var CommandNodeChildrenElement int32 + CommandNodeChildrenElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Children = append(ret.Children, CommandNodeChildrenElement) + } + switch ret.Flags { + case 1: + var CommandNodeRedirectNode1Tmp int32 + CommandNodeRedirectNode1Tmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.RedirectNode = CommandNodeRedirectNode1Tmp + default: + var CommandNodeRedirectNodeTmp struct { + } + ret.RedirectNode = CommandNodeRedirectNodeTmp + } + switch ret.Flags { + case 0: + var CommandNodeExtraNodeData0Tmp struct { + } + ret.ExtraNodeData = CommandNodeExtraNodeData0Tmp + case 1: + var CommandNodeExtraNodeData1Tmp struct { + Name string + } + CommandNodeExtraNodeData1Tmp.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.ExtraNodeData = CommandNodeExtraNodeData1Tmp + case 2: + var CommandNodeExtraNodeData2Tmp struct { + Name string + Parser string + Properties any + SuggestionType any + } + CommandNodeExtraNodeData2Tmp.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + var CommandNodeExtraNodeDataParserKey int32 + CommandNodeExtraNodeDataParserKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.Parser, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataParserMap, CommandNodeExtraNodeDataParserKey) + if err != nil { + return + } + switch CommandNodeExtraNodeData2Tmp.Parser { + case "brigadier:bool": + var CommandNodeExtraNodeDataPropertiesBrigadierBoolTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesBrigadierBoolTmp + case "brigadier:double": + var CommandNodeExtraNodeDataPropertiesBrigadierDoubleTmp struct { + Flags uint8 + Min any + Max any + } + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesBrigadierDoubleTmp.Flags) + if err != nil { + return + } + switch CommandNodeExtraNodeDataPropertiesBrigadierDoubleTmp.Flags { + case 1: + var CommandNodeExtraNodeDataPropertiesMin1Tmp float64 + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMin1Tmp) + if err != nil { + return + } + CommandNodeExtraNodeDataPropertiesBrigadierDoubleTmp.Min = CommandNodeExtraNodeDataPropertiesMin1Tmp + default: + var CommandNodeExtraNodeDataPropertiesMinTmp struct { + } + CommandNodeExtraNodeDataPropertiesBrigadierDoubleTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp + } + switch CommandNodeExtraNodeDataPropertiesBrigadierDoubleTmp.Flags { + case 1: + var CommandNodeExtraNodeDataPropertiesMax1Tmp float64 + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMax1Tmp) + if err != nil { + return + } + CommandNodeExtraNodeDataPropertiesBrigadierDoubleTmp.Max = CommandNodeExtraNodeDataPropertiesMax1Tmp + default: + var CommandNodeExtraNodeDataPropertiesMaxTmp struct { + } + CommandNodeExtraNodeDataPropertiesBrigadierDoubleTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesBrigadierDoubleTmp + case "brigadier:float": + var CommandNodeExtraNodeDataPropertiesBrigadierFloatTmp struct { + Flags uint8 + Min any + Max any + } + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesBrigadierFloatTmp.Flags) + if err != nil { + return + } + switch CommandNodeExtraNodeDataPropertiesBrigadierFloatTmp.Flags { + case 1: + var CommandNodeExtraNodeDataPropertiesMin1Tmp float32 + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMin1Tmp) + if err != nil { + return + } + CommandNodeExtraNodeDataPropertiesBrigadierFloatTmp.Min = CommandNodeExtraNodeDataPropertiesMin1Tmp + default: + var CommandNodeExtraNodeDataPropertiesMinTmp struct { + } + CommandNodeExtraNodeDataPropertiesBrigadierFloatTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp + } + switch CommandNodeExtraNodeDataPropertiesBrigadierFloatTmp.Flags { + case 1: + var CommandNodeExtraNodeDataPropertiesMax1Tmp float32 + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMax1Tmp) + if err != nil { + return + } + CommandNodeExtraNodeDataPropertiesBrigadierFloatTmp.Max = CommandNodeExtraNodeDataPropertiesMax1Tmp + default: + var CommandNodeExtraNodeDataPropertiesMaxTmp struct { + } + CommandNodeExtraNodeDataPropertiesBrigadierFloatTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesBrigadierFloatTmp + case "brigadier:integer": + var CommandNodeExtraNodeDataPropertiesBrigadierIntegerTmp struct { + Flags uint8 + Min any + Max any + } + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesBrigadierIntegerTmp.Flags) + if err != nil { + return + } + switch CommandNodeExtraNodeDataPropertiesBrigadierIntegerTmp.Flags { + case 1: + var CommandNodeExtraNodeDataPropertiesMin1Tmp int32 + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMin1Tmp) + if err != nil { + return + } + CommandNodeExtraNodeDataPropertiesBrigadierIntegerTmp.Min = CommandNodeExtraNodeDataPropertiesMin1Tmp + default: + var CommandNodeExtraNodeDataPropertiesMinTmp struct { + } + CommandNodeExtraNodeDataPropertiesBrigadierIntegerTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp + } + switch CommandNodeExtraNodeDataPropertiesBrigadierIntegerTmp.Flags { + case 1: + var CommandNodeExtraNodeDataPropertiesMax1Tmp int32 + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMax1Tmp) + if err != nil { + return + } + CommandNodeExtraNodeDataPropertiesBrigadierIntegerTmp.Max = CommandNodeExtraNodeDataPropertiesMax1Tmp + default: + var CommandNodeExtraNodeDataPropertiesMaxTmp struct { + } + CommandNodeExtraNodeDataPropertiesBrigadierIntegerTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesBrigadierIntegerTmp + case "brigadier:long": + var CommandNodeExtraNodeDataPropertiesBrigadierLongTmp struct { + Flags uint8 + Min any + Max any + } + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesBrigadierLongTmp.Flags) + if err != nil { + return + } + switch CommandNodeExtraNodeDataPropertiesBrigadierLongTmp.Flags { + case 1: + var CommandNodeExtraNodeDataPropertiesMin1Tmp int64 + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMin1Tmp) + if err != nil { + return + } + CommandNodeExtraNodeDataPropertiesBrigadierLongTmp.Min = CommandNodeExtraNodeDataPropertiesMin1Tmp + default: + var CommandNodeExtraNodeDataPropertiesMinTmp struct { + } + CommandNodeExtraNodeDataPropertiesBrigadierLongTmp.Min = CommandNodeExtraNodeDataPropertiesMinTmp + } + switch CommandNodeExtraNodeDataPropertiesBrigadierLongTmp.Flags { + case 1: + var CommandNodeExtraNodeDataPropertiesMax1Tmp int64 + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMax1Tmp) + if err != nil { + return + } + CommandNodeExtraNodeDataPropertiesBrigadierLongTmp.Max = CommandNodeExtraNodeDataPropertiesMax1Tmp + default: + var CommandNodeExtraNodeDataPropertiesMaxTmp struct { + } + CommandNodeExtraNodeDataPropertiesBrigadierLongTmp.Max = CommandNodeExtraNodeDataPropertiesMaxTmp + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesBrigadierLongTmp + case "brigadier:string": + var CommandNodeExtraNodeDataPropertiesBrigadierStringTmp string + var CommandNodeExtraNodeDataPropertiesKey int32 + CommandNodeExtraNodeDataPropertiesKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + CommandNodeExtraNodeDataPropertiesBrigadierStringTmp, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataPropertiesMap, CommandNodeExtraNodeDataPropertiesKey) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesBrigadierStringTmp + case "minecraft:angle": + var CommandNodeExtraNodeDataPropertiesMinecraftAngleTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftAngleTmp + case "minecraft:block_pos": + var CommandNodeExtraNodeDataPropertiesMinecraftBlockPosTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftBlockPosTmp + case "minecraft:block_predicate": + var CommandNodeExtraNodeDataPropertiesMinecraftBlockPredicateTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftBlockPredicateTmp + case "minecraft:block_state": + var CommandNodeExtraNodeDataPropertiesMinecraftBlockStateTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftBlockStateTmp + case "minecraft:color": + var CommandNodeExtraNodeDataPropertiesMinecraftColorTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftColorTmp + case "minecraft:column_pos": + var CommandNodeExtraNodeDataPropertiesMinecraftColumnPosTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftColumnPosTmp + case "minecraft:component": + var CommandNodeExtraNodeDataPropertiesMinecraftComponentTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftComponentTmp + case "minecraft:dialog": + var CommandNodeExtraNodeDataPropertiesMinecraftDialogTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftDialogTmp + case "minecraft:dimension": + var CommandNodeExtraNodeDataPropertiesMinecraftDimensionTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftDimensionTmp + case "minecraft:entity": + var CommandNodeExtraNodeDataPropertiesMinecraftEntityTmp uint8 + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMinecraftEntityTmp) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftEntityTmp + case "minecraft:entity_anchor": + var CommandNodeExtraNodeDataPropertiesMinecraftEntityAnchorTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftEntityAnchorTmp + case "minecraft:float_range": + var CommandNodeExtraNodeDataPropertiesMinecraftFloatRangeTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftFloatRangeTmp + case "minecraft:function": + var CommandNodeExtraNodeDataPropertiesMinecraftFunctionTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftFunctionTmp + case "minecraft:game_profile": + var CommandNodeExtraNodeDataPropertiesMinecraftGameProfileTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftGameProfileTmp + case "minecraft:gamemode": + var CommandNodeExtraNodeDataPropertiesMinecraftGamemodeTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftGamemodeTmp + case "minecraft:heightmap": + var CommandNodeExtraNodeDataPropertiesMinecraftHeightmapTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftHeightmapTmp + case "minecraft:hex_color": + var CommandNodeExtraNodeDataPropertiesMinecraftHexColorTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftHexColorTmp + case "minecraft:int_range": + var CommandNodeExtraNodeDataPropertiesMinecraftIntRangeTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftIntRangeTmp + case "minecraft:item_predicate": + var CommandNodeExtraNodeDataPropertiesMinecraftItemPredicateTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftItemPredicateTmp + case "minecraft:item_slot": + var CommandNodeExtraNodeDataPropertiesMinecraftItemSlotTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftItemSlotTmp + case "minecraft:item_stack": + var CommandNodeExtraNodeDataPropertiesMinecraftItemStackTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftItemStackTmp + case "minecraft:message": + var CommandNodeExtraNodeDataPropertiesMinecraftMessageTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftMessageTmp + case "minecraft:nbt": + var CommandNodeExtraNodeDataPropertiesMinecraftNbtTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftNbtTmp + case "minecraft:nbt_path": + var CommandNodeExtraNodeDataPropertiesMinecraftNbtPathTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftNbtPathTmp + case "minecraft:objective": + var CommandNodeExtraNodeDataPropertiesMinecraftObjectiveTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftObjectiveTmp + case "minecraft:objective_criteria": + var CommandNodeExtraNodeDataPropertiesMinecraftObjectiveCriteriaTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftObjectiveCriteriaTmp + case "minecraft:operation": + var CommandNodeExtraNodeDataPropertiesMinecraftOperationTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftOperationTmp + case "minecraft:particle": + var CommandNodeExtraNodeDataPropertiesMinecraftParticleTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftParticleTmp + case "minecraft:resource": + var CommandNodeExtraNodeDataPropertiesMinecraftResourceTmp struct { + Registry string + } + CommandNodeExtraNodeDataPropertiesMinecraftResourceTmp.Registry, err = proto_base.DecodeString(r) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftResourceTmp + case "minecraft:resource_key": + var CommandNodeExtraNodeDataPropertiesMinecraftResourceKeyTmp struct { + Registry string + } + CommandNodeExtraNodeDataPropertiesMinecraftResourceKeyTmp.Registry, err = proto_base.DecodeString(r) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftResourceKeyTmp + case "minecraft:resource_location": + var CommandNodeExtraNodeDataPropertiesMinecraftResourceLocationTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftResourceLocationTmp + case "minecraft:resource_or_tag": + var CommandNodeExtraNodeDataPropertiesMinecraftResourceOrTagTmp struct { + Registry string + } + CommandNodeExtraNodeDataPropertiesMinecraftResourceOrTagTmp.Registry, err = proto_base.DecodeString(r) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftResourceOrTagTmp + case "minecraft:resource_or_tag_key": + var CommandNodeExtraNodeDataPropertiesMinecraftResourceOrTagKeyTmp struct { + Registry string + } + CommandNodeExtraNodeDataPropertiesMinecraftResourceOrTagKeyTmp.Registry, err = proto_base.DecodeString(r) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftResourceOrTagKeyTmp + case "minecraft:resource_selector": + var CommandNodeExtraNodeDataPropertiesMinecraftResourceSelectorTmp struct { + Registry string + } + CommandNodeExtraNodeDataPropertiesMinecraftResourceSelectorTmp.Registry, err = proto_base.DecodeString(r) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftResourceSelectorTmp + case "minecraft:rotation": + var CommandNodeExtraNodeDataPropertiesMinecraftRotationTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftRotationTmp + case "minecraft:score_holder": + var CommandNodeExtraNodeDataPropertiesMinecraftScoreHolderTmp uint8 + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMinecraftScoreHolderTmp) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftScoreHolderTmp + case "minecraft:scoreboard_slot": + var CommandNodeExtraNodeDataPropertiesMinecraftScoreboardSlotTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftScoreboardSlotTmp + case "minecraft:swizzle": + var CommandNodeExtraNodeDataPropertiesMinecraftSwizzleTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftSwizzleTmp + case "minecraft:team": + var CommandNodeExtraNodeDataPropertiesMinecraftTeamTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftTeamTmp + case "minecraft:template_mirror": + var CommandNodeExtraNodeDataPropertiesMinecraftTemplateMirrorTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftTemplateMirrorTmp + case "minecraft:template_rotation": + var CommandNodeExtraNodeDataPropertiesMinecraftTemplateRotationTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftTemplateRotationTmp + case "minecraft:time": + var CommandNodeExtraNodeDataPropertiesMinecraftTimeTmp struct { + Min int32 + } + err = binary.Read(r, binary.BigEndian, &CommandNodeExtraNodeDataPropertiesMinecraftTimeTmp.Min) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftTimeTmp + case "minecraft:uuid": + var CommandNodeExtraNodeDataPropertiesMinecraftUuidTmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftUuidTmp + case "minecraft:vec2": + var CommandNodeExtraNodeDataPropertiesMinecraftVec2Tmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftVec2Tmp + case "minecraft:vec3": + var CommandNodeExtraNodeDataPropertiesMinecraftVec3Tmp struct { + } + CommandNodeExtraNodeData2Tmp.Properties = CommandNodeExtraNodeDataPropertiesMinecraftVec3Tmp + } + switch ret.Flags { + case 1: + var CommandNodeExtraNodeDataSuggestionType1Tmp string + CommandNodeExtraNodeDataSuggestionType1Tmp, err = proto_base.DecodeString(r) + if err != nil { + return + } + CommandNodeExtraNodeData2Tmp.SuggestionType = CommandNodeExtraNodeDataSuggestionType1Tmp + default: + var CommandNodeExtraNodeDataSuggestionTypeTmp struct { + } + CommandNodeExtraNodeData2Tmp.SuggestionType = CommandNodeExtraNodeDataSuggestionTypeTmp + } + ret.ExtraNodeData = CommandNodeExtraNodeData2Tmp + } + return +} + +var CommandNodeExtraNodeDataParserReverseMap = map[string]int32{"brigadier:bool": 0, "brigadier:float": 1, "minecraft:vec3": 10, "minecraft:vec2": 11, "minecraft:block_state": 12, "minecraft:block_predicate": 13, "minecraft:item_stack": 14, "minecraft:item_predicate": 15, "minecraft:color": 16, "minecraft:hex_color": 17, "minecraft:component": 18, "minecraft:style": 19, "brigadier:double": 2, "minecraft:message": 20, "minecraft:nbt": 21, "minecraft:nbt_tag": 22, "minecraft:nbt_path": 23, "minecraft:objective": 24, "minecraft:objective_criteria": 25, "minecraft:operation": 26, "minecraft:particle": 27, "minecraft:angle": 28, "minecraft:rotation": 29, "brigadier:integer": 3, "minecraft:scoreboard_slot": 30, "minecraft:score_holder": 31, "minecraft:swizzle": 32, "minecraft:team": 33, "minecraft:item_slot": 34, "minecraft:item_slots": 35, "minecraft:resource_location": 36, "minecraft:function": 37, "minecraft:entity_anchor": 38, "minecraft:int_range": 39, "brigadier:long": 4, "minecraft:float_range": 40, "minecraft:dimension": 41, "minecraft:gamemode": 42, "minecraft:time": 43, "minecraft:resource_or_tag": 44, "minecraft:resource_or_tag_key": 45, "minecraft:resource": 46, "minecraft:resource_key": 47, "minecraft:resource_selector": 48, "minecraft:template_mirror": 49, "brigadier:string": 5, "minecraft:template_rotation": 50, "minecraft:heightmap": 51, "minecraft:loot_table": 52, "minecraft:loot_predicate": 53, "minecraft:loot_modifier": 54, "minecraft:dialog": 55, "minecraft:uuid": 56, "minecraft:entity": 6, "minecraft:game_profile": 7, "minecraft:block_pos": 8, "minecraft:column_pos": 9} +var CommandNodeExtraNodeDataPropertiesReverseMap = map[string]int32{"SINGLE_WORD": 0, "QUOTABLE_PHRASE": 1, "GREEDY_PHRASE": 2} + +func (ret *CommandNode) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Flags) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Children))) + if err != nil { + return + } + for iCommandNodeChildren := range len(ret.Children) { + err = proto_base.EncodeVarInt(w, ret.Children[iCommandNodeChildren]) + if err != nil { + return + } + } + switch ret.Flags { + case 1: + CommandNodeRedirectNode, ok := ret.RedirectNode.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, CommandNodeRedirectNode) + if err != nil { + return + } + default: + _, ok := ret.RedirectNode.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Flags { + case 0: + _, ok := ret.ExtraNodeData.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case 1: + CommandNodeExtraNodeData, ok := ret.ExtraNodeData.(struct { + Name string + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, CommandNodeExtraNodeData.Name) + if err != nil { + return + } + case 2: + CommandNodeExtraNodeData, ok := ret.ExtraNodeData.(struct { + Name string + Parser string + Properties any + SuggestionType any + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, CommandNodeExtraNodeData.Name) + if err != nil { + return + } + var vCommandNodeExtraNodeDataParser int32 + vCommandNodeExtraNodeDataParser, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataParserReverseMap, CommandNodeExtraNodeData.Parser) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vCommandNodeExtraNodeDataParser) + if err != nil { + return + } + switch CommandNodeExtraNodeData.Parser { + case "brigadier:bool": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "brigadier:double": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { + Flags uint8 + Min any + Max any + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Flags) + if err != nil { + return + } + switch CommandNodeExtraNodeDataProperties.Flags { + case 1: + CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(float64) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin) + if err != nil { + return + } + default: + _, ok := CommandNodeExtraNodeDataProperties.Min.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch CommandNodeExtraNodeDataProperties.Flags { + case 1: + CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(float64) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax) + if err != nil { + return + } + default: + _, ok := CommandNodeExtraNodeDataProperties.Max.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + case "brigadier:float": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { + Flags uint8 + Min any + Max any + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Flags) + if err != nil { + return + } + switch CommandNodeExtraNodeDataProperties.Flags { + case 1: + CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(float32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin) + if err != nil { + return + } + default: + _, ok := CommandNodeExtraNodeDataProperties.Min.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch CommandNodeExtraNodeDataProperties.Flags { + case 1: + CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(float32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax) + if err != nil { + return + } + default: + _, ok := CommandNodeExtraNodeDataProperties.Max.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + case "brigadier:integer": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { + Flags uint8 + Min any + Max any + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Flags) + if err != nil { + return + } + switch CommandNodeExtraNodeDataProperties.Flags { + case 1: + CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin) + if err != nil { + return + } + default: + _, ok := CommandNodeExtraNodeDataProperties.Min.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch CommandNodeExtraNodeDataProperties.Flags { + case 1: + CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax) + if err != nil { + return + } + default: + _, ok := CommandNodeExtraNodeDataProperties.Max.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + case "brigadier:long": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { + Flags uint8 + Min any + Max any + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Flags) + if err != nil { + return + } + switch CommandNodeExtraNodeDataProperties.Flags { + case 1: + CommandNodeExtraNodeDataPropertiesMin, ok := CommandNodeExtraNodeDataProperties.Min.(int64) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMin) + if err != nil { + return + } + default: + _, ok := CommandNodeExtraNodeDataProperties.Min.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch CommandNodeExtraNodeDataProperties.Flags { + case 1: + CommandNodeExtraNodeDataPropertiesMax, ok := CommandNodeExtraNodeDataProperties.Max.(int64) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataPropertiesMax) + if err != nil { + return + } + default: + _, ok := CommandNodeExtraNodeDataProperties.Max.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + case "brigadier:string": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(string) + if !ok { + err = proto_base.BadTypeError + return + } + var vCommandNodeExtraNodeDataProperties int32 + vCommandNodeExtraNodeDataProperties, err = proto_base.ErroringIndex(CommandNodeExtraNodeDataPropertiesReverseMap, CommandNodeExtraNodeDataProperties) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vCommandNodeExtraNodeDataProperties) + if err != nil { + return + } + case "minecraft:angle": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:block_pos": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:block_predicate": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:block_state": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:color": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:column_pos": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:component": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:dialog": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:dimension": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:entity": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(uint8) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties) + if err != nil { + return + } + case "minecraft:entity_anchor": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:float_range": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:function": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:game_profile": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:gamemode": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:heightmap": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:hex_color": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:int_range": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:item_predicate": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:item_slot": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:item_stack": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:message": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:nbt": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:nbt_path": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:objective": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:objective_criteria": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:operation": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:particle": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:resource": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { + Registry string + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry) + if err != nil { + return + } + case "minecraft:resource_key": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { + Registry string + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry) + if err != nil { + return + } + case "minecraft:resource_location": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:resource_or_tag": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { + Registry string + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry) + if err != nil { + return + } + case "minecraft:resource_or_tag_key": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { + Registry string + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry) + if err != nil { + return + } + case "minecraft:resource_selector": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { + Registry string + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, CommandNodeExtraNodeDataProperties.Registry) + if err != nil { + return + } + case "minecraft:rotation": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:score_holder": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(uint8) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties) + if err != nil { + return + } + case "minecraft:scoreboard_slot": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:swizzle": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:team": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:template_mirror": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:template_rotation": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:time": + CommandNodeExtraNodeDataProperties, ok := CommandNodeExtraNodeData.Properties.(struct { + Min int32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, CommandNodeExtraNodeDataProperties.Min) + if err != nil { + return + } + case "minecraft:uuid": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:vec2": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + case "minecraft:vec3": + _, ok := CommandNodeExtraNodeData.Properties.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + switch ret.Flags { + case 1: + CommandNodeExtraNodeDataSuggestionType, ok := CommandNodeExtraNodeData.SuggestionType.(string) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, CommandNodeExtraNodeDataSuggestionType) + if err != nil { + return + } + default: + _, ok := CommandNodeExtraNodeData.SuggestionType.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + } + return +} + +type EntityMetadata struct { + Val proto_base.ToDo +} + +func (ret *EntityMetadata) Decode(r io.Reader) (err error) { + err = proto_base.ToDoError + return +} +func (ret *EntityMetadata) Encode(w io.Writer) (err error) { + err = proto_base.ToDoError + return +} + +type EntityMetadataEntry struct { + Key uint8 + Type string + Value any +} + +var EntityMetadataEntryTypeMap = map[int32]string{0: "byte", 1: "int", 10: "block_pos", 11: "optional_block_pos", 12: "direction", 13: "optional_uuid", 14: "block_state", 15: "optional_block_state", 16: "compound_tag", 17: "particle", 18: "particles", 19: "villager_data", 2: "long", 20: "optional_unsigned_int", 21: "pose", 22: "cat_variant", 23: "cow_variant", 24: "wolf_variant", 25: "wolf_sound_variant", 26: "frog_variant", 27: "pig_variant", 28: "chicken_variant", 29: "optional_global_pos", 3: "float", 30: "painting_variant", 31: "sniffer_state", 32: "armadillo_state", 33: "vector3", 34: "quaternion", 4: "string", 5: "component", 6: "optional_component", 7: "item_stack", 8: "boolean", 9: "rotations"} + +func (ret *EntityMetadataEntry) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Key) + if err != nil { + return + } + var EntityMetadataEntryTypeKey int32 + EntityMetadataEntryTypeKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Type, err = proto_base.ErroringIndex(EntityMetadataEntryTypeMap, EntityMetadataEntryTypeKey) + if err != nil { + return + } + switch ret.Type { + case "armadillo_state": + var EntityMetadataEntryValueArmadilloStateTmp int32 + EntityMetadataEntryValueArmadilloStateTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueArmadilloStateTmp + case "block_pos": + var EntityMetadataEntryValueBlockPosTmp Position + err = EntityMetadataEntryValueBlockPosTmp.Decode(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueBlockPosTmp + case "block_state": + var EntityMetadataEntryValueBlockStateTmp int32 + EntityMetadataEntryValueBlockStateTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueBlockStateTmp + case "boolean": + var EntityMetadataEntryValueBooleanTmp bool + err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueBooleanTmp) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueBooleanTmp + case "byte": + var EntityMetadataEntryValueByteTmp int8 + err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueByteTmp) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueByteTmp + case "cat_variant": + var EntityMetadataEntryValueCatVariantTmp int32 + EntityMetadataEntryValueCatVariantTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueCatVariantTmp + case "chicken_variant": + var EntityMetadataEntryValueChickenVariantTmp any + var EntityMetadataEntryValueId int32 + EntityMetadataEntryValueId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + if EntityMetadataEntryValueId != 0 { + EntityMetadataEntryValueChickenVariantTmp = EntityMetadataEntryValueId + } else { + var EntityMetadataEntryValueResult string + EntityMetadataEntryValueResult, err = proto_base.DecodeString(r) + if err != nil { + return + } + EntityMetadataEntryValueChickenVariantTmp = EntityMetadataEntryValueResult + } + ret.Value = EntityMetadataEntryValueChickenVariantTmp + case "component": + var EntityMetadataEntryValueComponentTmp nbt.Anon + err = EntityMetadataEntryValueComponentTmp.Decode(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueComponentTmp + case "compound_tag": + var EntityMetadataEntryValueCompoundTagTmp nbt.Anon + err = EntityMetadataEntryValueCompoundTagTmp.Decode(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueCompoundTagTmp + case "cow_variant": + var EntityMetadataEntryValueCowVariantTmp int32 + EntityMetadataEntryValueCowVariantTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueCowVariantTmp + case "direction": + var EntityMetadataEntryValueDirectionTmp int32 + EntityMetadataEntryValueDirectionTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueDirectionTmp + case "float": + var EntityMetadataEntryValueFloatTmp float32 + err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueFloatTmp) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueFloatTmp + case "frog_variant": + var EntityMetadataEntryValueFrogVariantTmp int32 + EntityMetadataEntryValueFrogVariantTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueFrogVariantTmp + case "int": + var EntityMetadataEntryValueIntTmp int32 + EntityMetadataEntryValueIntTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueIntTmp + case "item_stack": + var EntityMetadataEntryValueItemStackTmp Slot + err = EntityMetadataEntryValueItemStackTmp.Decode(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueItemStackTmp + case "long": + var EntityMetadataEntryValueLongTmp int64 + EntityMetadataEntryValueLongTmp, err = proto_base.DecodeVarLong(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueLongTmp + case "optional_block_pos": + var EntityMetadataEntryValueOptionalBlockPosTmp *Position + var EntityMetadataEntryValuePresent bool + err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValuePresent) + if err != nil { + return + } + if EntityMetadataEntryValuePresent { + var EntityMetadataEntryValuePresentValue Position + err = EntityMetadataEntryValuePresentValue.Decode(r) + if err != nil { + return + } + EntityMetadataEntryValueOptionalBlockPosTmp = &EntityMetadataEntryValuePresentValue + } + ret.Value = EntityMetadataEntryValueOptionalBlockPosTmp + case "optional_block_state": + var EntityMetadataEntryValueOptionalBlockStateTmp Optvarint + err = EntityMetadataEntryValueOptionalBlockStateTmp.Decode(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueOptionalBlockStateTmp + case "optional_component": + var EntityMetadataEntryValueOptionalComponentTmp *nbt.Anon + var EntityMetadataEntryValuePresent bool + err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValuePresent) + if err != nil { + return + } + if EntityMetadataEntryValuePresent { + var EntityMetadataEntryValuePresentValue nbt.Anon + err = EntityMetadataEntryValuePresentValue.Decode(r) + if err != nil { + return + } + EntityMetadataEntryValueOptionalComponentTmp = &EntityMetadataEntryValuePresentValue + } + ret.Value = EntityMetadataEntryValueOptionalComponentTmp + case "optional_global_pos": + var EntityMetadataEntryValueOptionalGlobalPosTmp *string + var EntityMetadataEntryValuePresent bool + err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValuePresent) + if err != nil { + return + } + if EntityMetadataEntryValuePresent { + var EntityMetadataEntryValuePresentValue string + EntityMetadataEntryValuePresentValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + EntityMetadataEntryValueOptionalGlobalPosTmp = &EntityMetadataEntryValuePresentValue + } + ret.Value = EntityMetadataEntryValueOptionalGlobalPosTmp + case "optional_unsigned_int": + var EntityMetadataEntryValueOptionalUnsignedIntTmp Optvarint + err = EntityMetadataEntryValueOptionalUnsignedIntTmp.Decode(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueOptionalUnsignedIntTmp + case "optional_uuid": + var EntityMetadataEntryValueOptionalUuidTmp *uuid.UUID + var EntityMetadataEntryValuePresent bool + err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValuePresent) + if err != nil { + return + } + if EntityMetadataEntryValuePresent { + var EntityMetadataEntryValuePresentValue uuid.UUID + _, err = io.ReadFull(r, EntityMetadataEntryValuePresentValue[:]) + if err != nil { + return + } + EntityMetadataEntryValueOptionalUuidTmp = &EntityMetadataEntryValuePresentValue + } + ret.Value = EntityMetadataEntryValueOptionalUuidTmp + case "painting_variant": + var EntityMetadataEntryValuePaintingVariantTmp any + var EntityMetadataEntryValueId int32 + EntityMetadataEntryValueId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + if EntityMetadataEntryValueId != 0 { + EntityMetadataEntryValuePaintingVariantTmp = EntityMetadataEntryValueId + } else { + var EntityMetadataEntryValueResult EntityMetadataPaintingVariant + err = EntityMetadataEntryValueResult.Decode(r) + if err != nil { + return + } + EntityMetadataEntryValuePaintingVariantTmp = EntityMetadataEntryValueResult + } + ret.Value = EntityMetadataEntryValuePaintingVariantTmp + case "particle": + var EntityMetadataEntryValueParticleTmp Particle + err = EntityMetadataEntryValueParticleTmp.Decode(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueParticleTmp + case "particles": + var EntityMetadataEntryValueParticlesTmp []Particle + var lEntityMetadataEntryValue int32 + lEntityMetadataEntryValue, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + EntityMetadataEntryValueParticlesTmp = []Particle{} + for range lEntityMetadataEntryValue { + var EntityMetadataEntryValueElement Particle + err = EntityMetadataEntryValueElement.Decode(r) + if err != nil { + return + } + EntityMetadataEntryValueParticlesTmp = append(EntityMetadataEntryValueParticlesTmp, EntityMetadataEntryValueElement) + } + ret.Value = EntityMetadataEntryValueParticlesTmp + case "pig_variant": + var EntityMetadataEntryValuePigVariantTmp int32 + EntityMetadataEntryValuePigVariantTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValuePigVariantTmp + case "pose": + var EntityMetadataEntryValuePoseTmp int32 + EntityMetadataEntryValuePoseTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValuePoseTmp + case "quaternion": + var EntityMetadataEntryValueQuaternionTmp Vec4f + err = EntityMetadataEntryValueQuaternionTmp.Decode(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueQuaternionTmp + case "rotations": + var EntityMetadataEntryValueRotationsTmp struct { + Pitch float32 + Yaw float32 + Roll float32 + } + err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Pitch) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Yaw) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &EntityMetadataEntryValueRotationsTmp.Roll) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueRotationsTmp + case "sniffer_state": + var EntityMetadataEntryValueSnifferStateTmp int32 + EntityMetadataEntryValueSnifferStateTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueSnifferStateTmp + case "string": + var EntityMetadataEntryValueStringTmp string + EntityMetadataEntryValueStringTmp, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueStringTmp + case "vector3": + var EntityMetadataEntryValueVector3Tmp Vec3f + err = EntityMetadataEntryValueVector3Tmp.Decode(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueVector3Tmp + case "villager_data": + var EntityMetadataEntryValueVillagerDataTmp struct { + VillagerType int32 + VillagerProfession int32 + Level int32 + } + EntityMetadataEntryValueVillagerDataTmp.VillagerType, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + EntityMetadataEntryValueVillagerDataTmp.VillagerProfession, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + EntityMetadataEntryValueVillagerDataTmp.Level, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueVillagerDataTmp + case "wolf_sound_variant": + var EntityMetadataEntryValueWolfSoundVariantTmp int32 + EntityMetadataEntryValueWolfSoundVariantTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueWolfSoundVariantTmp + case "wolf_variant": + var EntityMetadataEntryValueWolfVariantTmp int32 + EntityMetadataEntryValueWolfVariantTmp, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Value = EntityMetadataEntryValueWolfVariantTmp + } + return +} + +var EntityMetadataEntryTypeReverseMap = map[string]int32{"byte": 0, "int": 1, "block_pos": 10, "optional_block_pos": 11, "direction": 12, "optional_uuid": 13, "block_state": 14, "optional_block_state": 15, "compound_tag": 16, "particle": 17, "particles": 18, "villager_data": 19, "long": 2, "optional_unsigned_int": 20, "pose": 21, "cat_variant": 22, "cow_variant": 23, "wolf_variant": 24, "wolf_sound_variant": 25, "frog_variant": 26, "pig_variant": 27, "chicken_variant": 28, "optional_global_pos": 29, "float": 3, "painting_variant": 30, "sniffer_state": 31, "armadillo_state": 32, "vector3": 33, "quaternion": 34, "string": 4, "component": 5, "optional_component": 6, "item_stack": 7, "boolean": 8, "rotations": 9} + +func (ret *EntityMetadataEntry) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Key) + if err != nil { + return + } + var vEntityMetadataEntryType int32 + vEntityMetadataEntryType, err = proto_base.ErroringIndex(EntityMetadataEntryTypeReverseMap, ret.Type) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vEntityMetadataEntryType) + if err != nil { + return + } + switch ret.Type { + case "armadillo_state": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "block_pos": + EntityMetadataEntryValue, ok := ret.Value.(Position) + if !ok { + err = proto_base.BadTypeError + return + } + err = EntityMetadataEntryValue.Encode(w) + if err != nil { + return + } + case "block_state": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "boolean": + EntityMetadataEntryValue, ok := ret.Value.(bool) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue) + if err != nil { + return + } + case "byte": + EntityMetadataEntryValue, ok := ret.Value.(int8) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue) + if err != nil { + return + } + case "cat_variant": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "chicken_variant": + EntityMetadataEntryValue, ok := ret.Value.(any) + if !ok { + err = proto_base.BadTypeError + return + } + switch EntityMetadataEntryValueKnownType := EntityMetadataEntryValue.(type) { + case int32: + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValueKnownType) + if err != nil { + return + } + case string: + err = proto_base.EncodeVarInt(w, 0) + if err != nil { + return + } + err = proto_base.EncodeString(w, EntityMetadataEntryValueKnownType) + if err != nil { + return + } + default: + err = proto_base.BadTypeError + } + case "component": + EntityMetadataEntryValue, ok := ret.Value.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = EntityMetadataEntryValue.Encode(w) + if err != nil { + return + } + case "compound_tag": + EntityMetadataEntryValue, ok := ret.Value.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = EntityMetadataEntryValue.Encode(w) + if err != nil { + return + } + case "cow_variant": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "direction": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "float": + EntityMetadataEntryValue, ok := ret.Value.(float32) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue) + if err != nil { + return + } + case "frog_variant": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "int": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "item_stack": + EntityMetadataEntryValue, ok := ret.Value.(Slot) + if !ok { + err = proto_base.BadTypeError + return + } + err = EntityMetadataEntryValue.Encode(w) + if err != nil { + return + } + case "long": + EntityMetadataEntryValue, ok := ret.Value.(int64) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarLong(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "optional_block_pos": + EntityMetadataEntryValue, ok := ret.Value.(*Position) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil) + if err != nil { + return + } + if EntityMetadataEntryValue != nil { + err = (*EntityMetadataEntryValue).Encode(w) + if err != nil { + return + } + } + case "optional_block_state": + EntityMetadataEntryValue, ok := ret.Value.(Optvarint) + if !ok { + err = proto_base.BadTypeError + return + } + err = EntityMetadataEntryValue.Encode(w) + if err != nil { + return + } + case "optional_component": + EntityMetadataEntryValue, ok := ret.Value.(*nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil) + if err != nil { + return + } + if EntityMetadataEntryValue != nil { + err = (*EntityMetadataEntryValue).Encode(w) + if err != nil { + return + } + } + case "optional_global_pos": + EntityMetadataEntryValue, ok := ret.Value.(*string) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil) + if err != nil { + return + } + if EntityMetadataEntryValue != nil { + err = proto_base.EncodeString(w, *EntityMetadataEntryValue) + if err != nil { + return + } + } + case "optional_unsigned_int": + EntityMetadataEntryValue, ok := ret.Value.(Optvarint) + if !ok { + err = proto_base.BadTypeError + return + } + err = EntityMetadataEntryValue.Encode(w) + if err != nil { + return + } + case "optional_uuid": + EntityMetadataEntryValue, ok := ret.Value.(*uuid.UUID) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue != nil) + if err != nil { + return + } + if EntityMetadataEntryValue != nil { + _, err = w.Write((*EntityMetadataEntryValue)[:]) + if err != nil { + return + } + } + case "painting_variant": + EntityMetadataEntryValue, ok := ret.Value.(any) + if !ok { + err = proto_base.BadTypeError + return + } + switch EntityMetadataEntryValueKnownType := EntityMetadataEntryValue.(type) { + case int32: + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValueKnownType) + if err != nil { + return + } + case EntityMetadataPaintingVariant: + err = proto_base.EncodeVarInt(w, 0) + if err != nil { + return + } + err = EntityMetadataEntryValueKnownType.Encode(w) + if err != nil { + return + } + default: + err = proto_base.BadTypeError + } + case "particle": + EntityMetadataEntryValue, ok := ret.Value.(Particle) + if !ok { + err = proto_base.BadTypeError + return + } + err = EntityMetadataEntryValue.Encode(w) + if err != nil { + return + } + case "particles": + EntityMetadataEntryValue, ok := ret.Value.([]Particle) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, int32(len(EntityMetadataEntryValue))) + if err != nil { + return + } + for iEntityMetadataEntryValue := range len(EntityMetadataEntryValue) { + err = EntityMetadataEntryValue[iEntityMetadataEntryValue].Encode(w) + if err != nil { + return + } + } + case "pig_variant": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "pose": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "quaternion": + EntityMetadataEntryValue, ok := ret.Value.(Vec4f) + if !ok { + err = proto_base.BadTypeError + return + } + err = EntityMetadataEntryValue.Encode(w) + if err != nil { + return + } + case "rotations": + EntityMetadataEntryValue, ok := ret.Value.(struct { + Pitch float32 + Yaw float32 + Roll float32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Pitch) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Yaw) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, EntityMetadataEntryValue.Roll) + if err != nil { + return + } + case "sniffer_state": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "string": + EntityMetadataEntryValue, ok := ret.Value.(string) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeString(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "vector3": + EntityMetadataEntryValue, ok := ret.Value.(Vec3f) + if !ok { + err = proto_base.BadTypeError + return + } + err = EntityMetadataEntryValue.Encode(w) + if err != nil { + return + } + case "villager_data": + EntityMetadataEntryValue, ok := ret.Value.(struct { + VillagerType int32 + VillagerProfession int32 + Level int32 + }) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.VillagerType) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.VillagerProfession) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue.Level) + if err != nil { + return + } + case "wolf_sound_variant": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + case "wolf_variant": + EntityMetadataEntryValue, ok := ret.Value.(int32) + if !ok { + err = proto_base.BadTypeError + return + } + err = proto_base.EncodeVarInt(w, EntityMetadataEntryValue) + if err != nil { + return + } + } + return +} + +type GameProfile struct { + Name string + Properties []struct { + Name string + Value string + Signature *string + } +} + +func (ret *GameProfile) Decode(r io.Reader) (err error) { + ret.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + var lGameProfileProperties int32 + lGameProfileProperties, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Properties = []struct { + Name string + Value string + Signature *string + }{} + for range lGameProfileProperties { + var GameProfilePropertiesElement struct { + Name string + Value string + Signature *string + } + GameProfilePropertiesElement.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + GameProfilePropertiesElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + var GameProfilePropertiesElementSignaturePresent bool + err = binary.Read(r, binary.BigEndian, &GameProfilePropertiesElementSignaturePresent) + if err != nil { + return + } + if GameProfilePropertiesElementSignaturePresent { + var GameProfilePropertiesElementSignaturePresentValue string + GameProfilePropertiesElementSignaturePresentValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + GameProfilePropertiesElement.Signature = &GameProfilePropertiesElementSignaturePresentValue + } + ret.Properties = append(ret.Properties, GameProfilePropertiesElement) + } + return +} +func (ret *GameProfile) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Properties))) + if err != nil { + return + } + for iGameProfileProperties := range len(ret.Properties) { + err = proto_base.EncodeString(w, ret.Properties[iGameProfileProperties].Name) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Properties[iGameProfileProperties].Value) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Properties[iGameProfileProperties].Signature != nil) + if err != nil { + return + } + if ret.Properties[iGameProfileProperties].Signature != nil { + err = proto_base.EncodeString(w, *ret.Properties[iGameProfileProperties].Signature) + if err != nil { + return + } + } + } + return +} + +type Ingredient struct { + Val []Slot +} + +func (ret *Ingredient) Decode(r io.Reader) (err error) { + var lIngredient int32 + lIngredient, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Val = []Slot{} + for range lIngredient { + var IngredientElement Slot + err = IngredientElement.Decode(r) + if err != nil { + return + } + ret.Val = append(ret.Val, IngredientElement) + } + return +} +func (ret *Ingredient) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Val))) + if err != nil { + return + } + for iIngredient := range len(ret.Val) { + err = ret.Val[iIngredient].Encode(w) + if err != nil { + return + } + } + return +} + +type Optvarint struct { + Val int32 +} + +func (ret *Optvarint) Decode(r io.Reader) (err error) { + ret.Val, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *Optvarint) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Val) + if err != nil { + return + } + return +} + +type PackedChunkPos struct { + Z int32 + X int32 +} + +func (ret *PackedChunkPos) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + return +} +func (ret *PackedChunkPos) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + return +} + +type Position struct { + Val uint64 +} + +func (ret *Position) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Val) + if err != nil { + return + } + return +} +func (ret *Position) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Val) + if err != nil { + return + } + return +} + +type PreviousMessages struct { + Val []struct { + Id int32 + Signature any + } +} + +func (ret *PreviousMessages) Decode(r io.Reader) (err error) { + var lPreviousMessages int32 + lPreviousMessages, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Val = []struct { + Id int32 + Signature any + }{} + for range lPreviousMessages { + var PreviousMessagesElement struct { + Id int32 + Signature any + } + PreviousMessagesElement.Id, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + switch PreviousMessagesElement.Id { + case 0: + var PreviousMessagesElementSignature0Tmp [256]byte + _, err = r.Read(PreviousMessagesElementSignature0Tmp[:]) + if err != nil { + return + } + PreviousMessagesElement.Signature = PreviousMessagesElementSignature0Tmp + default: + var PreviousMessagesElementSignatureTmp struct { + } + PreviousMessagesElement.Signature = PreviousMessagesElementSignatureTmp + } + ret.Val = append(ret.Val, PreviousMessagesElement) + } + return +} +func (ret *PreviousMessages) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Val))) + if err != nil { + return + } + for iPreviousMessages := range len(ret.Val) { + err = proto_base.EncodeVarInt(w, ret.Val[iPreviousMessages].Id) + if err != nil { + return + } + switch ret.Val[iPreviousMessages].Id { + case 0: + PreviousMessagesInnerSignature, ok := ret.Val[iPreviousMessages].Signature.([256]byte) + if !ok { + err = proto_base.BadTypeError + return + } + arr := PreviousMessagesInnerSignature + _, err = w.Write(arr[:]) + if err != nil { + return + } + default: + _, ok := ret.Val[iPreviousMessages].Signature.(struct { + }) + if !ok { + err = proto_base.BadTypeError + return + } + } + } + return +} + +type SoundSource struct { + Val string +} + +var SoundSourceMap = map[int32]string{0: "master", 1: "music", 10: "ui", 2: "record", 3: "weather", 4: "block", 5: "hostile", 6: "neutral", 7: "player", 8: "ambient", 9: "voice"} + +func (ret *SoundSource) Decode(r io.Reader) (err error) { + var SoundSourceKey int32 + SoundSourceKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Val, err = proto_base.ErroringIndex(SoundSourceMap, SoundSourceKey) + if err != nil { + return + } + return +} + +var SoundSourceReverseMap = map[string]int32{"master": 0, "music": 1, "ui": 10, "record": 2, "weather": 3, "block": 4, "hostile": 5, "neutral": 6, "player": 7, "ambient": 8, "voice": 9} + +func (ret *SoundSource) Encode(w io.Writer) (err error) { + var vSoundSource int32 + vSoundSource, err = proto_base.ErroringIndex(SoundSourceReverseMap, ret.Val) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vSoundSource) + if err != nil { + return + } + return +} + +type Tags struct { + Val []struct { + TagName string + Entries []int32 + } +} + +func (ret *Tags) Decode(r io.Reader) (err error) { + var lTags int32 + lTags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Val = []struct { + TagName string + Entries []int32 + }{} + for range lTags { + var TagsElement struct { + TagName string + Entries []int32 + } + TagsElement.TagName, err = proto_base.DecodeString(r) + if err != nil { + return + } + var lTagsElementEntries int32 + lTagsElementEntries, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + TagsElement.Entries = []int32{} + for range lTagsElementEntries { + var TagsElementEntriesElement int32 + TagsElementEntriesElement, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + TagsElement.Entries = append(TagsElement.Entries, TagsElementEntriesElement) + } + ret.Val = append(ret.Val, TagsElement) + } + return +} +func (ret *Tags) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Val))) + if err != nil { + return + } + for iTags := range len(ret.Val) { + err = proto_base.EncodeString(w, ret.Val[iTags].TagName) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Val[iTags].Entries))) + if err != nil { + return + } + for iTagsInnerEntries := range len(ret.Val[iTags].Entries) { + err = proto_base.EncodeVarInt(w, ret.Val[iTags].Entries[iTagsInnerEntries]) + if err != nil { + return + } + } + } + return +} + +type Vec2f struct { + X float32 + Y float32 +} + +func (ret *Vec2f) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + return +} +func (ret *Vec2f) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + return +} + +type Vec3f struct { + X float32 + Y float32 + Z float32 +} + +func (ret *Vec3f) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + return +} +func (ret *Vec3f) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + return +} + +type Vec3f64 struct { + X float64 + Y float64 + Z float64 +} + +func (ret *Vec3f64) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + return +} +func (ret *Vec3f64) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + return +} + +type Vec3i struct { + X int32 + Y int32 + Z int32 +} + +func (ret *Vec3i) Decode(r io.Reader) (err error) { + ret.X, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Y, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Z, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *Vec3i) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.X) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Y) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Z) + if err != nil { + return + } + return +} + +type Vec4f struct { + X float32 + Y float32 + Z float32 + W float32 +} + +func (ret *Vec4f) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.X) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Y) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Z) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.W) + if err != nil { + return + } + return +} +func (ret *Vec4f) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.X) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Y) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Z) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.W) + if err != nil { + return + } + return +} + +type StatusToServerPacket struct { + Name string + Params any +} + +var StatusToServerPacketNameMap = map[int32]string{0x00: "ping_start", 0x01: "ping"} + +func (ret *StatusToServerPacket) Decode(r io.Reader) (err error) { + var StatusToServerPacketNameKey int32 + StatusToServerPacketNameKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.ErroringIndex(StatusToServerPacketNameMap, StatusToServerPacketNameKey) + if err != nil { + return + } + switch ret.Name { + case "ping": + var StatusToServerPacketParamsPingTmp StatusToServerPacketPing + err = StatusToServerPacketParamsPingTmp.Decode(r) + if err != nil { + return + } + ret.Params = StatusToServerPacketParamsPingTmp + case "ping_start": + var StatusToServerPacketParamsPingStartTmp StatusToServerPacketPingStart + err = StatusToServerPacketParamsPingStartTmp.Decode(r) + if err != nil { + return + } + ret.Params = StatusToServerPacketParamsPingStartTmp + } + return +} + +var StatusToServerPacketNameReverseMap = map[string]int32{"ping_start": 0x00, "ping": 0x01} + +func (ret *StatusToServerPacket) Encode(w io.Writer) (err error) { + var vStatusToServerPacketName int32 + vStatusToServerPacketName, err = proto_base.ErroringIndex(StatusToServerPacketNameReverseMap, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vStatusToServerPacketName) + if err != nil { + return + } + switch ret.Name { + case "ping": + StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPing) + if !ok { + err = proto_base.BadTypeError + return + } + err = StatusToServerPacketParams.Encode(w) + if err != nil { + return + } + case "ping_start": + StatusToServerPacketParams, ok := ret.Params.(StatusToServerPacketPingStart) + if !ok { + err = proto_base.BadTypeError + return + } + err = StatusToServerPacketParams.Encode(w) + if err != nil { + return + } + } + return +} + +type StatusToServerPacketCommonAddResourcePack struct { + Uuid uuid.UUID + Url string + Hash string + Forced bool + PromptMessage *nbt.Anon +} + +func (ret *StatusToServerPacketCommonAddResourcePack) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Url, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Hash, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Forced) + if err != nil { + return + } + var StatusToServerPacketCommonAddResourcePackPromptMessagePresent bool + err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonAddResourcePackPromptMessagePresent) + if err != nil { + return + } + if StatusToServerPacketCommonAddResourcePackPromptMessagePresent { + var StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon + err = StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.PromptMessage = &StatusToServerPacketCommonAddResourcePackPromptMessagePresentValue + } + return +} +func (ret *StatusToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Url) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Hash) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Forced) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) + if err != nil { + return + } + if ret.PromptMessage != nil { + err = (*ret.PromptMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type StatusToServerPacketCommonClearDialog struct { +} + +func (ret *StatusToServerPacketCommonClearDialog) Decode(r io.Reader) (err error) { + return +} +func (ret *StatusToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) { + return +} + +type StatusToServerPacketCommonCookieRequest struct { + Cookie string +} + +func (ret *StatusToServerPacketCommonCookieRequest) Decode(r io.Reader) (err error) { + ret.Cookie, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *StatusToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Cookie) + if err != nil { + return + } + return +} + +type StatusToServerPacketCommonCookieResponse struct { + Key string + Value *ByteArray +} + +func (ret *StatusToServerPacketCommonCookieResponse) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var StatusToServerPacketCommonCookieResponseValuePresent bool + err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonCookieResponseValuePresent) + if err != nil { + return + } + if StatusToServerPacketCommonCookieResponseValuePresent { + var StatusToServerPacketCommonCookieResponseValuePresentValue ByteArray + err = StatusToServerPacketCommonCookieResponseValuePresentValue.Decode(r) + if err != nil { + return + } + ret.Value = &StatusToServerPacketCommonCookieResponseValuePresentValue + } + return +} +func (ret *StatusToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value != nil) + if err != nil { + return + } + if ret.Value != nil { + err = (*ret.Value).Encode(w) + if err != nil { + return + } + } + return +} + +type StatusToServerPacketCommonCustomClickAction struct { + Id string + Nbt *nbt.Anon +} + +func (ret *StatusToServerPacketCommonCustomClickAction) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var StatusToServerPacketCommonCustomClickActionNbtPresent bool + err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonCustomClickActionNbtPresent) + if err != nil { + return + } + if StatusToServerPacketCommonCustomClickActionNbtPresent { + var StatusToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon + err = StatusToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r) + if err != nil { + return + } + ret.Nbt = &StatusToServerPacketCommonCustomClickActionNbtPresentValue + } + return +} +func (ret *StatusToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) + if err != nil { + return + } + if ret.Nbt != nil { + err = (*ret.Nbt).Encode(w) + if err != nil { + return + } + } + return +} + +type StatusToServerPacketCommonCustomReportDetails struct { + Details []struct { + Key string + Value string + } +} + +func (ret *StatusToServerPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) { + var lStatusToServerPacketCommonCustomReportDetailsDetails int32 + lStatusToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Details = []struct { + Key string + Value string + }{} + for range lStatusToServerPacketCommonCustomReportDetailsDetails { + var StatusToServerPacketCommonCustomReportDetailsDetailsElement struct { + Key string + Value string + } + StatusToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + StatusToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Details = append(ret.Details, StatusToServerPacketCommonCustomReportDetailsDetailsElement) + } + return +} +func (ret *StatusToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) + if err != nil { + return + } + for iStatusToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) { + err = proto_base.EncodeString(w, ret.Details[iStatusToServerPacketCommonCustomReportDetailsDetails].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Details[iStatusToServerPacketCommonCustomReportDetailsDetails].Value) + if err != nil { + return + } + } + return +} + +type StatusToServerPacketCommonRemoveResourcePack struct { + Uuid *uuid.UUID +} + +func (ret *StatusToServerPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) { + var StatusToServerPacketCommonRemoveResourcePackUuidPresent bool + err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonRemoveResourcePackUuidPresent) + if err != nil { + return + } + if StatusToServerPacketCommonRemoveResourcePackUuidPresent { + var StatusToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID + _, err = io.ReadFull(r, StatusToServerPacketCommonRemoveResourcePackUuidPresentValue[:]) + if err != nil { + return + } + ret.Uuid = &StatusToServerPacketCommonRemoveResourcePackUuidPresentValue + } + return +} +func (ret *StatusToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) + if err != nil { + return + } + if ret.Uuid != nil { + _, err = w.Write((*ret.Uuid)[:]) + if err != nil { + return + } + } + return +} + +type StatusToServerPacketCommonSelectKnownPacks struct { + Packs []struct { + Namespace string + Id string + Version string + } +} + +func (ret *StatusToServerPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) { + var lStatusToServerPacketCommonSelectKnownPacksPacks int32 + lStatusToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Packs = []struct { + Namespace string + Id string + Version string + }{} + for range lStatusToServerPacketCommonSelectKnownPacksPacks { + var StatusToServerPacketCommonSelectKnownPacksPacksElement struct { + Namespace string + Id string + Version string + } + StatusToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) + if err != nil { + return + } + StatusToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + StatusToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Packs = append(ret.Packs, StatusToServerPacketCommonSelectKnownPacksPacksElement) + } + return +} +func (ret *StatusToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) + if err != nil { + return + } + for iStatusToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { + err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Namespace) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Id) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iStatusToServerPacketCommonSelectKnownPacksPacks].Version) + if err != nil { + return + } + } + return +} + +type StatusToServerPacketCommonServerLinks struct { + Links []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } +} + +func (ret *StatusToServerPacketCommonServerLinks) Decode(r io.Reader) (err error) { + var lStatusToServerPacketCommonServerLinksLinks int32 + lStatusToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Links = []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + }{} + for range lStatusToServerPacketCommonServerLinksLinks { + var StatusToServerPacketCommonServerLinksLinksElement struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } + err = binary.Read(r, binary.BigEndian, &StatusToServerPacketCommonServerLinksLinksElement.HasKnownType) + if err != nil { + return + } + switch StatusToServerPacketCommonServerLinksLinksElement.HasKnownType { + case true: + var StatusToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType + err = StatusToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) + if err != nil { + return + } + StatusToServerPacketCommonServerLinksLinksElement.KnownType = StatusToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp + } + switch StatusToServerPacketCommonServerLinksLinksElement.HasKnownType { + case false: + var StatusToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon + err = StatusToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) + if err != nil { + return + } + StatusToServerPacketCommonServerLinksLinksElement.UnknownType = StatusToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp + } + StatusToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Links = append(ret.Links, StatusToServerPacketCommonServerLinksLinksElement) + } + return +} +func (ret *StatusToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) + if err != nil { + return + } + for iStatusToServerPacketCommonServerLinksLinks := range len(ret.Links) { + err = binary.Write(w, binary.BigEndian, ret.Links[iStatusToServerPacketCommonServerLinksLinks].HasKnownType) + if err != nil { + return + } + switch ret.Links[iStatusToServerPacketCommonServerLinksLinks].HasKnownType { + case true: + StatusToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iStatusToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType) + if !ok { + err = proto_base.BadTypeError + return + } + err = StatusToServerPacketCommonServerLinksLinksInnerKnownType.Encode(w) + if err != nil { + return + } + } + switch ret.Links[iStatusToServerPacketCommonServerLinksLinks].HasKnownType { + case false: + StatusToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iStatusToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = StatusToServerPacketCommonServerLinksLinksInnerUnknownType.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Links[iStatusToServerPacketCommonServerLinksLinks].Link) + if err != nil { + return + } + } + return +} + +type StatusToServerPacketCommonSettings struct { + Locale string + ViewDistance int8 + ChatFlags int32 + ChatColors bool + SkinParts uint8 + MainHand int32 + EnableTextFiltering bool + EnableServerListing bool + ParticleStatus string +} + +var StatusToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} + +func (ret *StatusToServerPacketCommonSettings) Decode(r io.Reader) (err error) { + ret.Locale, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ViewDistance) + if err != nil { + return + } + ret.ChatFlags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChatColors) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SkinParts) + if err != nil { + return + } + ret.MainHand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) + if err != nil { + return + } + var StatusToServerPacketCommonSettingsParticleStatusKey int32 + StatusToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ParticleStatus, err = proto_base.ErroringIndex(StatusToServerPacketCommonSettingsParticleStatusMap, StatusToServerPacketCommonSettingsParticleStatusKey) + if err != nil { + return + } + return +} + +var StatusToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} + +func (ret *StatusToServerPacketCommonSettings) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Locale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChatFlags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChatColors) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SkinParts) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.MainHand) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) + if err != nil { + return + } + var vStatusToServerPacketCommonSettingsParticleStatus int32 + vStatusToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(StatusToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vStatusToServerPacketCommonSettingsParticleStatus) + if err != nil { + return + } + return +} + +type StatusToServerPacketCommonStoreCookie struct { + Key string + Value ByteArray +} + +func (ret *StatusToServerPacketCommonStoreCookie) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Value.Decode(r) + if err != nil { + return + } + return +} +func (ret *StatusToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = ret.Value.Encode(w) + if err != nil { + return + } + return +} + +type StatusToServerPacketCommonTransfer struct { + Host string + Port int32 +} + +func (ret *StatusToServerPacketCommonTransfer) Decode(r io.Reader) (err error) { + ret.Host, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Port, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *StatusToServerPacketCommonTransfer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Host) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Port) + if err != nil { + return + } + return +} + +type StatusToServerPacketPing struct { + Time int64 +} + +func (ret *StatusToServerPacketPing) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Time) + if err != nil { + return + } + return +} +func (ret *StatusToServerPacketPing) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Time) + if err != nil { + return + } + return +} + +type StatusToServerPacketPingStart struct { +} + +func (ret *StatusToServerPacketPingStart) Decode(r io.Reader) (err error) { + return +} +func (ret *StatusToServerPacketPingStart) Encode(w io.Writer) (err error) { + return +} + +type StatusToClientPacket struct { + Name string + Params any +} + +var StatusToClientPacketNameMap = map[int32]string{0x00: "server_info", 0x01: "ping"} + +func (ret *StatusToClientPacket) Decode(r io.Reader) (err error) { + var StatusToClientPacketNameKey int32 + StatusToClientPacketNameKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.ErroringIndex(StatusToClientPacketNameMap, StatusToClientPacketNameKey) + if err != nil { + return + } + switch ret.Name { + case "ping": + var StatusToClientPacketParamsPingTmp StatusToClientPacketPing + err = StatusToClientPacketParamsPingTmp.Decode(r) + if err != nil { + return + } + ret.Params = StatusToClientPacketParamsPingTmp + case "server_info": + var StatusToClientPacketParamsServerInfoTmp StatusToClientPacketServerInfo + err = StatusToClientPacketParamsServerInfoTmp.Decode(r) + if err != nil { + return + } + ret.Params = StatusToClientPacketParamsServerInfoTmp + } + return +} + +var StatusToClientPacketNameReverseMap = map[string]int32{"server_info": 0x00, "ping": 0x01} + +func (ret *StatusToClientPacket) Encode(w io.Writer) (err error) { + var vStatusToClientPacketName int32 + vStatusToClientPacketName, err = proto_base.ErroringIndex(StatusToClientPacketNameReverseMap, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vStatusToClientPacketName) + if err != nil { + return + } + switch ret.Name { + case "ping": + StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketPing) + if !ok { + err = proto_base.BadTypeError + return + } + err = StatusToClientPacketParams.Encode(w) + if err != nil { + return + } + case "server_info": + StatusToClientPacketParams, ok := ret.Params.(StatusToClientPacketServerInfo) + if !ok { + err = proto_base.BadTypeError + return + } + err = StatusToClientPacketParams.Encode(w) + if err != nil { + return + } + } + return +} + +type StatusToClientPacketCommonAddResourcePack struct { + Uuid uuid.UUID + Url string + Hash string + Forced bool + PromptMessage *nbt.Anon +} + +func (ret *StatusToClientPacketCommonAddResourcePack) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Url, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Hash, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Forced) + if err != nil { + return + } + var StatusToClientPacketCommonAddResourcePackPromptMessagePresent bool + err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonAddResourcePackPromptMessagePresent) + if err != nil { + return + } + if StatusToClientPacketCommonAddResourcePackPromptMessagePresent { + var StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon + err = StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.PromptMessage = &StatusToClientPacketCommonAddResourcePackPromptMessagePresentValue + } + return +} +func (ret *StatusToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Url) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Hash) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Forced) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) + if err != nil { + return + } + if ret.PromptMessage != nil { + err = (*ret.PromptMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type StatusToClientPacketCommonClearDialog struct { +} + +func (ret *StatusToClientPacketCommonClearDialog) Decode(r io.Reader) (err error) { + return +} +func (ret *StatusToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) { + return +} + +type StatusToClientPacketCommonCookieRequest struct { + Cookie string +} + +func (ret *StatusToClientPacketCommonCookieRequest) Decode(r io.Reader) (err error) { + ret.Cookie, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *StatusToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Cookie) + if err != nil { + return + } + return +} + +type StatusToClientPacketCommonCookieResponse struct { + Key string + Value *ByteArray +} + +func (ret *StatusToClientPacketCommonCookieResponse) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var StatusToClientPacketCommonCookieResponseValuePresent bool + err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonCookieResponseValuePresent) + if err != nil { + return + } + if StatusToClientPacketCommonCookieResponseValuePresent { + var StatusToClientPacketCommonCookieResponseValuePresentValue ByteArray + err = StatusToClientPacketCommonCookieResponseValuePresentValue.Decode(r) + if err != nil { + return + } + ret.Value = &StatusToClientPacketCommonCookieResponseValuePresentValue + } + return +} +func (ret *StatusToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value != nil) + if err != nil { + return + } + if ret.Value != nil { + err = (*ret.Value).Encode(w) + if err != nil { + return + } + } + return +} + +type StatusToClientPacketCommonCustomClickAction struct { + Id string + Nbt *nbt.Anon +} + +func (ret *StatusToClientPacketCommonCustomClickAction) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var StatusToClientPacketCommonCustomClickActionNbtPresent bool + err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonCustomClickActionNbtPresent) + if err != nil { + return + } + if StatusToClientPacketCommonCustomClickActionNbtPresent { + var StatusToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon + err = StatusToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r) + if err != nil { + return + } + ret.Nbt = &StatusToClientPacketCommonCustomClickActionNbtPresentValue + } + return +} +func (ret *StatusToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) + if err != nil { + return + } + if ret.Nbt != nil { + err = (*ret.Nbt).Encode(w) + if err != nil { + return + } + } + return +} + +type StatusToClientPacketCommonCustomReportDetails struct { + Details []struct { + Key string + Value string + } +} + +func (ret *StatusToClientPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) { + var lStatusToClientPacketCommonCustomReportDetailsDetails int32 + lStatusToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Details = []struct { + Key string + Value string + }{} + for range lStatusToClientPacketCommonCustomReportDetailsDetails { + var StatusToClientPacketCommonCustomReportDetailsDetailsElement struct { + Key string + Value string + } + StatusToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + StatusToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Details = append(ret.Details, StatusToClientPacketCommonCustomReportDetailsDetailsElement) + } + return +} +func (ret *StatusToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) + if err != nil { + return + } + for iStatusToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) { + err = proto_base.EncodeString(w, ret.Details[iStatusToClientPacketCommonCustomReportDetailsDetails].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Details[iStatusToClientPacketCommonCustomReportDetailsDetails].Value) + if err != nil { + return + } + } + return +} + +type StatusToClientPacketCommonRemoveResourcePack struct { + Uuid *uuid.UUID +} + +func (ret *StatusToClientPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) { + var StatusToClientPacketCommonRemoveResourcePackUuidPresent bool + err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonRemoveResourcePackUuidPresent) + if err != nil { + return + } + if StatusToClientPacketCommonRemoveResourcePackUuidPresent { + var StatusToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID + _, err = io.ReadFull(r, StatusToClientPacketCommonRemoveResourcePackUuidPresentValue[:]) + if err != nil { + return + } + ret.Uuid = &StatusToClientPacketCommonRemoveResourcePackUuidPresentValue + } + return +} +func (ret *StatusToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) + if err != nil { + return + } + if ret.Uuid != nil { + _, err = w.Write((*ret.Uuid)[:]) + if err != nil { + return + } + } + return +} + +type StatusToClientPacketCommonSelectKnownPacks struct { + Packs []struct { + Namespace string + Id string + Version string + } +} + +func (ret *StatusToClientPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) { + var lStatusToClientPacketCommonSelectKnownPacksPacks int32 + lStatusToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Packs = []struct { + Namespace string + Id string + Version string + }{} + for range lStatusToClientPacketCommonSelectKnownPacksPacks { + var StatusToClientPacketCommonSelectKnownPacksPacksElement struct { + Namespace string + Id string + Version string + } + StatusToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) + if err != nil { + return + } + StatusToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + StatusToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Packs = append(ret.Packs, StatusToClientPacketCommonSelectKnownPacksPacksElement) + } + return +} +func (ret *StatusToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) + if err != nil { + return + } + for iStatusToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { + err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Namespace) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Id) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iStatusToClientPacketCommonSelectKnownPacksPacks].Version) + if err != nil { + return + } + } + return +} + +type StatusToClientPacketCommonServerLinks struct { + Links []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } +} + +func (ret *StatusToClientPacketCommonServerLinks) Decode(r io.Reader) (err error) { + var lStatusToClientPacketCommonServerLinksLinks int32 + lStatusToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Links = []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + }{} + for range lStatusToClientPacketCommonServerLinksLinks { + var StatusToClientPacketCommonServerLinksLinksElement struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } + err = binary.Read(r, binary.BigEndian, &StatusToClientPacketCommonServerLinksLinksElement.HasKnownType) + if err != nil { + return + } + switch StatusToClientPacketCommonServerLinksLinksElement.HasKnownType { + case true: + var StatusToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType + err = StatusToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) + if err != nil { + return + } + StatusToClientPacketCommonServerLinksLinksElement.KnownType = StatusToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp + } + switch StatusToClientPacketCommonServerLinksLinksElement.HasKnownType { + case false: + var StatusToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon + err = StatusToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) + if err != nil { + return + } + StatusToClientPacketCommonServerLinksLinksElement.UnknownType = StatusToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp + } + StatusToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Links = append(ret.Links, StatusToClientPacketCommonServerLinksLinksElement) + } + return +} +func (ret *StatusToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) + if err != nil { + return + } + for iStatusToClientPacketCommonServerLinksLinks := range len(ret.Links) { + err = binary.Write(w, binary.BigEndian, ret.Links[iStatusToClientPacketCommonServerLinksLinks].HasKnownType) + if err != nil { + return + } + switch ret.Links[iStatusToClientPacketCommonServerLinksLinks].HasKnownType { + case true: + StatusToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iStatusToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType) + if !ok { + err = proto_base.BadTypeError + return + } + err = StatusToClientPacketCommonServerLinksLinksInnerKnownType.Encode(w) + if err != nil { + return + } + } + switch ret.Links[iStatusToClientPacketCommonServerLinksLinks].HasKnownType { + case false: + StatusToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iStatusToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = StatusToClientPacketCommonServerLinksLinksInnerUnknownType.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Links[iStatusToClientPacketCommonServerLinksLinks].Link) + if err != nil { + return + } + } + return +} + +type StatusToClientPacketCommonSettings struct { + Locale string + ViewDistance int8 + ChatFlags int32 + ChatColors bool + SkinParts uint8 + MainHand int32 + EnableTextFiltering bool + EnableServerListing bool + ParticleStatus string +} + +var StatusToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} + +func (ret *StatusToClientPacketCommonSettings) Decode(r io.Reader) (err error) { + ret.Locale, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ViewDistance) + if err != nil { + return + } + ret.ChatFlags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChatColors) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SkinParts) + if err != nil { + return + } + ret.MainHand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) + if err != nil { + return + } + var StatusToClientPacketCommonSettingsParticleStatusKey int32 + StatusToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ParticleStatus, err = proto_base.ErroringIndex(StatusToClientPacketCommonSettingsParticleStatusMap, StatusToClientPacketCommonSettingsParticleStatusKey) + if err != nil { + return + } + return +} + +var StatusToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} + +func (ret *StatusToClientPacketCommonSettings) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Locale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChatFlags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChatColors) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SkinParts) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.MainHand) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) + if err != nil { + return + } + var vStatusToClientPacketCommonSettingsParticleStatus int32 + vStatusToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(StatusToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vStatusToClientPacketCommonSettingsParticleStatus) + if err != nil { + return + } + return +} + +type StatusToClientPacketCommonStoreCookie struct { + Key string + Value ByteArray +} + +func (ret *StatusToClientPacketCommonStoreCookie) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Value.Decode(r) + if err != nil { + return + } + return +} +func (ret *StatusToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = ret.Value.Encode(w) + if err != nil { + return + } + return +} + +type StatusToClientPacketCommonTransfer struct { + Host string + Port int32 +} + +func (ret *StatusToClientPacketCommonTransfer) Decode(r io.Reader) (err error) { + ret.Host, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Port, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *StatusToClientPacketCommonTransfer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Host) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Port) + if err != nil { + return + } + return +} + +type StatusToClientPacketPing struct { + Time int64 +} + +func (ret *StatusToClientPacketPing) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Time) + if err != nil { + return + } + return +} +func (ret *StatusToClientPacketPing) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Time) + if err != nil { + return + } + return +} + +type StatusToClientPacketServerInfo struct { + Response string +} + +func (ret *StatusToClientPacketServerInfo) Decode(r io.Reader) (err error) { + ret.Response, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *StatusToClientPacketServerInfo) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Response) + if err != nil { + return + } + return +} + +type LoginToServerPacket struct { + Name string + Params any +} + +var LoginToServerPacketNameMap = map[int32]string{0x00: "login_start", 0x01: "encryption_begin", 0x02: "login_plugin_response", 0x03: "login_acknowledged", 0x04: "cookie_response"} + +func (ret *LoginToServerPacket) Decode(r io.Reader) (err error) { + var LoginToServerPacketNameKey int32 + LoginToServerPacketNameKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.ErroringIndex(LoginToServerPacketNameMap, LoginToServerPacketNameKey) + if err != nil { + return + } + switch ret.Name { + case "cookie_response": + var LoginToServerPacketParamsCookieResponseTmp LoginToServerPacketCommonCookieResponse + err = LoginToServerPacketParamsCookieResponseTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToServerPacketParamsCookieResponseTmp + case "encryption_begin": + var LoginToServerPacketParamsEncryptionBeginTmp LoginToServerPacketEncryptionBegin + err = LoginToServerPacketParamsEncryptionBeginTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToServerPacketParamsEncryptionBeginTmp + case "login_acknowledged": + var LoginToServerPacketParamsLoginAcknowledgedTmp LoginToServerPacketLoginAcknowledged + err = LoginToServerPacketParamsLoginAcknowledgedTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToServerPacketParamsLoginAcknowledgedTmp + case "login_plugin_response": + var LoginToServerPacketParamsLoginPluginResponseTmp LoginToServerPacketLoginPluginResponse + err = LoginToServerPacketParamsLoginPluginResponseTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToServerPacketParamsLoginPluginResponseTmp + case "login_start": + var LoginToServerPacketParamsLoginStartTmp LoginToServerPacketLoginStart + err = LoginToServerPacketParamsLoginStartTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToServerPacketParamsLoginStartTmp + } + return +} + +var LoginToServerPacketNameReverseMap = map[string]int32{"login_start": 0x00, "encryption_begin": 0x01, "login_plugin_response": 0x02, "login_acknowledged": 0x03, "cookie_response": 0x04} + +func (ret *LoginToServerPacket) Encode(w io.Writer) (err error) { + var vLoginToServerPacketName int32 + vLoginToServerPacketName, err = proto_base.ErroringIndex(LoginToServerPacketNameReverseMap, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vLoginToServerPacketName) + if err != nil { + return + } + switch ret.Name { + case "cookie_response": + LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketCommonCookieResponse) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToServerPacketParams.Encode(w) + if err != nil { + return + } + case "encryption_begin": + LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketEncryptionBegin) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToServerPacketParams.Encode(w) + if err != nil { + return + } + case "login_acknowledged": + LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginAcknowledged) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToServerPacketParams.Encode(w) + if err != nil { + return + } + case "login_plugin_response": + LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginPluginResponse) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToServerPacketParams.Encode(w) + if err != nil { + return + } + case "login_start": + LoginToServerPacketParams, ok := ret.Params.(LoginToServerPacketLoginStart) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToServerPacketParams.Encode(w) + if err != nil { + return + } + } + return +} + +type LoginToServerPacketCommonAddResourcePack struct { + Uuid uuid.UUID + Url string + Hash string + Forced bool + PromptMessage *nbt.Anon +} + +func (ret *LoginToServerPacketCommonAddResourcePack) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Url, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Hash, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Forced) + if err != nil { + return + } + var LoginToServerPacketCommonAddResourcePackPromptMessagePresent bool + err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonAddResourcePackPromptMessagePresent) + if err != nil { + return + } + if LoginToServerPacketCommonAddResourcePackPromptMessagePresent { + var LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon + err = LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.PromptMessage = &LoginToServerPacketCommonAddResourcePackPromptMessagePresentValue + } + return +} +func (ret *LoginToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Url) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Hash) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Forced) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) + if err != nil { + return + } + if ret.PromptMessage != nil { + err = (*ret.PromptMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type LoginToServerPacketCommonClearDialog struct { +} + +func (ret *LoginToServerPacketCommonClearDialog) Decode(r io.Reader) (err error) { + return +} +func (ret *LoginToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) { + return +} + +type LoginToServerPacketCommonCookieRequest struct { + Cookie string +} + +func (ret *LoginToServerPacketCommonCookieRequest) Decode(r io.Reader) (err error) { + ret.Cookie, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *LoginToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Cookie) + if err != nil { + return + } + return +} + +type LoginToServerPacketCommonCookieResponse struct { + Key string + Value *ByteArray +} + +func (ret *LoginToServerPacketCommonCookieResponse) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var LoginToServerPacketCommonCookieResponseValuePresent bool + err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonCookieResponseValuePresent) + if err != nil { + return + } + if LoginToServerPacketCommonCookieResponseValuePresent { + var LoginToServerPacketCommonCookieResponseValuePresentValue ByteArray + err = LoginToServerPacketCommonCookieResponseValuePresentValue.Decode(r) + if err != nil { + return + } + ret.Value = &LoginToServerPacketCommonCookieResponseValuePresentValue + } + return +} +func (ret *LoginToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value != nil) + if err != nil { + return + } + if ret.Value != nil { + err = (*ret.Value).Encode(w) + if err != nil { + return + } + } + return +} + +type LoginToServerPacketCommonCustomClickAction struct { + Id string + Nbt *nbt.Anon +} + +func (ret *LoginToServerPacketCommonCustomClickAction) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var LoginToServerPacketCommonCustomClickActionNbtPresent bool + err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonCustomClickActionNbtPresent) + if err != nil { + return + } + if LoginToServerPacketCommonCustomClickActionNbtPresent { + var LoginToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon + err = LoginToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r) + if err != nil { + return + } + ret.Nbt = &LoginToServerPacketCommonCustomClickActionNbtPresentValue + } + return +} +func (ret *LoginToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) + if err != nil { + return + } + if ret.Nbt != nil { + err = (*ret.Nbt).Encode(w) + if err != nil { + return + } + } + return +} + +type LoginToServerPacketCommonCustomReportDetails struct { + Details []struct { + Key string + Value string + } +} + +func (ret *LoginToServerPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) { + var lLoginToServerPacketCommonCustomReportDetailsDetails int32 + lLoginToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Details = []struct { + Key string + Value string + }{} + for range lLoginToServerPacketCommonCustomReportDetailsDetails { + var LoginToServerPacketCommonCustomReportDetailsDetailsElement struct { + Key string + Value string + } + LoginToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + LoginToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Details = append(ret.Details, LoginToServerPacketCommonCustomReportDetailsDetailsElement) + } + return +} +func (ret *LoginToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) + if err != nil { + return + } + for iLoginToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) { + err = proto_base.EncodeString(w, ret.Details[iLoginToServerPacketCommonCustomReportDetailsDetails].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Details[iLoginToServerPacketCommonCustomReportDetailsDetails].Value) + if err != nil { + return + } + } + return +} + +type LoginToServerPacketCommonRemoveResourcePack struct { + Uuid *uuid.UUID +} + +func (ret *LoginToServerPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) { + var LoginToServerPacketCommonRemoveResourcePackUuidPresent bool + err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonRemoveResourcePackUuidPresent) + if err != nil { + return + } + if LoginToServerPacketCommonRemoveResourcePackUuidPresent { + var LoginToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID + _, err = io.ReadFull(r, LoginToServerPacketCommonRemoveResourcePackUuidPresentValue[:]) + if err != nil { + return + } + ret.Uuid = &LoginToServerPacketCommonRemoveResourcePackUuidPresentValue + } + return +} +func (ret *LoginToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) + if err != nil { + return + } + if ret.Uuid != nil { + _, err = w.Write((*ret.Uuid)[:]) + if err != nil { + return + } + } + return +} + +type LoginToServerPacketCommonSelectKnownPacks struct { + Packs []struct { + Namespace string + Id string + Version string + } +} + +func (ret *LoginToServerPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) { + var lLoginToServerPacketCommonSelectKnownPacksPacks int32 + lLoginToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Packs = []struct { + Namespace string + Id string + Version string + }{} + for range lLoginToServerPacketCommonSelectKnownPacksPacks { + var LoginToServerPacketCommonSelectKnownPacksPacksElement struct { + Namespace string + Id string + Version string + } + LoginToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) + if err != nil { + return + } + LoginToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + LoginToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Packs = append(ret.Packs, LoginToServerPacketCommonSelectKnownPacksPacksElement) + } + return +} +func (ret *LoginToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) + if err != nil { + return + } + for iLoginToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { + err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Namespace) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Id) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iLoginToServerPacketCommonSelectKnownPacksPacks].Version) + if err != nil { + return + } + } + return +} + +type LoginToServerPacketCommonServerLinks struct { + Links []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } +} + +func (ret *LoginToServerPacketCommonServerLinks) Decode(r io.Reader) (err error) { + var lLoginToServerPacketCommonServerLinksLinks int32 + lLoginToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Links = []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + }{} + for range lLoginToServerPacketCommonServerLinksLinks { + var LoginToServerPacketCommonServerLinksLinksElement struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } + err = binary.Read(r, binary.BigEndian, &LoginToServerPacketCommonServerLinksLinksElement.HasKnownType) + if err != nil { + return + } + switch LoginToServerPacketCommonServerLinksLinksElement.HasKnownType { + case true: + var LoginToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType + err = LoginToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) + if err != nil { + return + } + LoginToServerPacketCommonServerLinksLinksElement.KnownType = LoginToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp + } + switch LoginToServerPacketCommonServerLinksLinksElement.HasKnownType { + case false: + var LoginToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon + err = LoginToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) + if err != nil { + return + } + LoginToServerPacketCommonServerLinksLinksElement.UnknownType = LoginToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp + } + LoginToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Links = append(ret.Links, LoginToServerPacketCommonServerLinksLinksElement) + } + return +} +func (ret *LoginToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) + if err != nil { + return + } + for iLoginToServerPacketCommonServerLinksLinks := range len(ret.Links) { + err = binary.Write(w, binary.BigEndian, ret.Links[iLoginToServerPacketCommonServerLinksLinks].HasKnownType) + if err != nil { + return + } + switch ret.Links[iLoginToServerPacketCommonServerLinksLinks].HasKnownType { + case true: + LoginToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iLoginToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToServerPacketCommonServerLinksLinksInnerKnownType.Encode(w) + if err != nil { + return + } + } + switch ret.Links[iLoginToServerPacketCommonServerLinksLinks].HasKnownType { + case false: + LoginToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iLoginToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToServerPacketCommonServerLinksLinksInnerUnknownType.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Links[iLoginToServerPacketCommonServerLinksLinks].Link) + if err != nil { + return + } + } + return +} + +type LoginToServerPacketCommonSettings struct { + Locale string + ViewDistance int8 + ChatFlags int32 + ChatColors bool + SkinParts uint8 + MainHand int32 + EnableTextFiltering bool + EnableServerListing bool + ParticleStatus string +} + +var LoginToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} + +func (ret *LoginToServerPacketCommonSettings) Decode(r io.Reader) (err error) { + ret.Locale, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ViewDistance) + if err != nil { + return + } + ret.ChatFlags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChatColors) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SkinParts) + if err != nil { + return + } + ret.MainHand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) + if err != nil { + return + } + var LoginToServerPacketCommonSettingsParticleStatusKey int32 + LoginToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ParticleStatus, err = proto_base.ErroringIndex(LoginToServerPacketCommonSettingsParticleStatusMap, LoginToServerPacketCommonSettingsParticleStatusKey) + if err != nil { + return + } + return +} + +var LoginToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} + +func (ret *LoginToServerPacketCommonSettings) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Locale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChatFlags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChatColors) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SkinParts) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.MainHand) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) + if err != nil { + return + } + var vLoginToServerPacketCommonSettingsParticleStatus int32 + vLoginToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(LoginToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vLoginToServerPacketCommonSettingsParticleStatus) + if err != nil { + return + } + return +} + +type LoginToServerPacketCommonStoreCookie struct { + Key string + Value ByteArray +} + +func (ret *LoginToServerPacketCommonStoreCookie) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Value.Decode(r) + if err != nil { + return + } + return +} +func (ret *LoginToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = ret.Value.Encode(w) + if err != nil { + return + } + return +} + +type LoginToServerPacketCommonTransfer struct { + Host string + Port int32 +} + +func (ret *LoginToServerPacketCommonTransfer) Decode(r io.Reader) (err error) { + ret.Host, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Port, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *LoginToServerPacketCommonTransfer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Host) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Port) + if err != nil { + return + } + return +} + +type LoginToServerPacketEncryptionBegin struct { + SharedSecret []byte + VerifyToken []byte +} + +func (ret *LoginToServerPacketEncryptionBegin) Decode(r io.Reader) (err error) { + var lLoginToServerPacketEncryptionBeginSharedSecret int32 + lLoginToServerPacketEncryptionBeginSharedSecret, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.SharedSecret, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginSharedSecret))) + if err != nil { + return + } + var lLoginToServerPacketEncryptionBeginVerifyToken int32 + lLoginToServerPacketEncryptionBeginVerifyToken, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.VerifyToken, err = io.ReadAll(io.LimitReader(r, int64(lLoginToServerPacketEncryptionBeginVerifyToken))) + if err != nil { + return + } + return +} +func (ret *LoginToServerPacketEncryptionBegin) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.SharedSecret))) + if err != nil { + return + } + _, err = w.Write(ret.SharedSecret) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.VerifyToken))) + if err != nil { + return + } + _, err = w.Write(ret.VerifyToken) + if err != nil { + return + } + return +} + +type LoginToServerPacketLoginAcknowledged struct { +} + +func (ret *LoginToServerPacketLoginAcknowledged) Decode(r io.Reader) (err error) { + return +} +func (ret *LoginToServerPacketLoginAcknowledged) Encode(w io.Writer) (err error) { + return +} + +type LoginToServerPacketLoginPluginResponse struct { + MessageId int32 + Data *proto_base.RestBuffer +} + +func (ret *LoginToServerPacketLoginPluginResponse) Decode(r io.Reader) (err error) { + ret.MessageId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + var LoginToServerPacketLoginPluginResponseDataPresent bool + err = binary.Read(r, binary.BigEndian, &LoginToServerPacketLoginPluginResponseDataPresent) + if err != nil { + return + } + if LoginToServerPacketLoginPluginResponseDataPresent { + var LoginToServerPacketLoginPluginResponseDataPresentValue proto_base.RestBuffer + err = LoginToServerPacketLoginPluginResponseDataPresentValue.Decode(r) + if err != nil { + return + } + ret.Data = &LoginToServerPacketLoginPluginResponseDataPresentValue + } + return +} +func (ret *LoginToServerPacketLoginPluginResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.MessageId) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Data != nil) + if err != nil { + return + } + if ret.Data != nil { + err = (*ret.Data).Encode(w) + if err != nil { + return + } + } + return +} + +type LoginToServerPacketLoginStart struct { + Username string + PlayerUUID uuid.UUID +} + +func (ret *LoginToServerPacketLoginStart) Decode(r io.Reader) (err error) { + ret.Username, err = proto_base.DecodeString(r) + if err != nil { + return + } + _, err = io.ReadFull(r, ret.PlayerUUID[:]) + if err != nil { + return + } + return +} +func (ret *LoginToServerPacketLoginStart) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Username) + if err != nil { + return + } + _, err = w.Write(ret.PlayerUUID[:]) + if err != nil { + return + } + return +} + +type LoginToClientPacket struct { + Name string + Params any +} + +var LoginToClientPacketNameMap = map[int32]string{0x00: "disconnect", 0x01: "encryption_begin", 0x02: "success", 0x03: "compress", 0x04: "login_plugin_request", 0x05: "cookie_request"} + +func (ret *LoginToClientPacket) Decode(r io.Reader) (err error) { + var LoginToClientPacketNameKey int32 + LoginToClientPacketNameKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.ErroringIndex(LoginToClientPacketNameMap, LoginToClientPacketNameKey) + if err != nil { + return + } + switch ret.Name { + case "compress": + var LoginToClientPacketParamsCompressTmp LoginToClientPacketCompress + err = LoginToClientPacketParamsCompressTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToClientPacketParamsCompressTmp + case "cookie_request": + var LoginToClientPacketParamsCookieRequestTmp LoginToClientPacketCommonCookieRequest + err = LoginToClientPacketParamsCookieRequestTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToClientPacketParamsCookieRequestTmp + case "disconnect": + var LoginToClientPacketParamsDisconnectTmp LoginToClientPacketDisconnect + err = LoginToClientPacketParamsDisconnectTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToClientPacketParamsDisconnectTmp + case "encryption_begin": + var LoginToClientPacketParamsEncryptionBeginTmp LoginToClientPacketEncryptionBegin + err = LoginToClientPacketParamsEncryptionBeginTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToClientPacketParamsEncryptionBeginTmp + case "login_plugin_request": + var LoginToClientPacketParamsLoginPluginRequestTmp LoginToClientPacketLoginPluginRequest + err = LoginToClientPacketParamsLoginPluginRequestTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToClientPacketParamsLoginPluginRequestTmp + case "success": + var LoginToClientPacketParamsSuccessTmp LoginToClientPacketSuccess + err = LoginToClientPacketParamsSuccessTmp.Decode(r) + if err != nil { + return + } + ret.Params = LoginToClientPacketParamsSuccessTmp + } + return +} + +var LoginToClientPacketNameReverseMap = map[string]int32{"disconnect": 0x00, "encryption_begin": 0x01, "success": 0x02, "compress": 0x03, "login_plugin_request": 0x04, "cookie_request": 0x05} + +func (ret *LoginToClientPacket) Encode(w io.Writer) (err error) { + var vLoginToClientPacketName int32 + vLoginToClientPacketName, err = proto_base.ErroringIndex(LoginToClientPacketNameReverseMap, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vLoginToClientPacketName) + if err != nil { + return + } + switch ret.Name { + case "compress": + LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketCompress) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToClientPacketParams.Encode(w) + if err != nil { + return + } + case "cookie_request": + LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketCommonCookieRequest) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToClientPacketParams.Encode(w) + if err != nil { + return + } + case "disconnect": + LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketDisconnect) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToClientPacketParams.Encode(w) + if err != nil { + return + } + case "encryption_begin": + LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketEncryptionBegin) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToClientPacketParams.Encode(w) + if err != nil { + return + } + case "login_plugin_request": + LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketLoginPluginRequest) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToClientPacketParams.Encode(w) + if err != nil { + return + } + case "success": + LoginToClientPacketParams, ok := ret.Params.(LoginToClientPacketSuccess) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToClientPacketParams.Encode(w) + if err != nil { + return + } + } + return +} + +type LoginToClientPacketCommonAddResourcePack struct { + Uuid uuid.UUID + Url string + Hash string + Forced bool + PromptMessage *nbt.Anon +} + +func (ret *LoginToClientPacketCommonAddResourcePack) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Url, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Hash, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Forced) + if err != nil { + return + } + var LoginToClientPacketCommonAddResourcePackPromptMessagePresent bool + err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonAddResourcePackPromptMessagePresent) + if err != nil { + return + } + if LoginToClientPacketCommonAddResourcePackPromptMessagePresent { + var LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon + err = LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.PromptMessage = &LoginToClientPacketCommonAddResourcePackPromptMessagePresentValue + } + return +} +func (ret *LoginToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Url) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Hash) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Forced) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) + if err != nil { + return + } + if ret.PromptMessage != nil { + err = (*ret.PromptMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type LoginToClientPacketCommonClearDialog struct { +} + +func (ret *LoginToClientPacketCommonClearDialog) Decode(r io.Reader) (err error) { + return +} +func (ret *LoginToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) { + return +} + +type LoginToClientPacketCommonCookieRequest struct { + Cookie string +} + +func (ret *LoginToClientPacketCommonCookieRequest) Decode(r io.Reader) (err error) { + ret.Cookie, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *LoginToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Cookie) + if err != nil { + return + } + return +} + +type LoginToClientPacketCommonCookieResponse struct { + Key string + Value *ByteArray +} + +func (ret *LoginToClientPacketCommonCookieResponse) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var LoginToClientPacketCommonCookieResponseValuePresent bool + err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonCookieResponseValuePresent) + if err != nil { + return + } + if LoginToClientPacketCommonCookieResponseValuePresent { + var LoginToClientPacketCommonCookieResponseValuePresentValue ByteArray + err = LoginToClientPacketCommonCookieResponseValuePresentValue.Decode(r) + if err != nil { + return + } + ret.Value = &LoginToClientPacketCommonCookieResponseValuePresentValue + } + return +} +func (ret *LoginToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value != nil) + if err != nil { + return + } + if ret.Value != nil { + err = (*ret.Value).Encode(w) + if err != nil { + return + } + } + return +} + +type LoginToClientPacketCommonCustomClickAction struct { + Id string + Nbt *nbt.Anon +} + +func (ret *LoginToClientPacketCommonCustomClickAction) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var LoginToClientPacketCommonCustomClickActionNbtPresent bool + err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonCustomClickActionNbtPresent) + if err != nil { + return + } + if LoginToClientPacketCommonCustomClickActionNbtPresent { + var LoginToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon + err = LoginToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r) + if err != nil { + return + } + ret.Nbt = &LoginToClientPacketCommonCustomClickActionNbtPresentValue + } + return +} +func (ret *LoginToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) + if err != nil { + return + } + if ret.Nbt != nil { + err = (*ret.Nbt).Encode(w) + if err != nil { + return + } + } + return +} + +type LoginToClientPacketCommonCustomReportDetails struct { + Details []struct { + Key string + Value string + } +} + +func (ret *LoginToClientPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) { + var lLoginToClientPacketCommonCustomReportDetailsDetails int32 + lLoginToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Details = []struct { + Key string + Value string + }{} + for range lLoginToClientPacketCommonCustomReportDetailsDetails { + var LoginToClientPacketCommonCustomReportDetailsDetailsElement struct { + Key string + Value string + } + LoginToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + LoginToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Details = append(ret.Details, LoginToClientPacketCommonCustomReportDetailsDetailsElement) + } + return +} +func (ret *LoginToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) + if err != nil { + return + } + for iLoginToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) { + err = proto_base.EncodeString(w, ret.Details[iLoginToClientPacketCommonCustomReportDetailsDetails].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Details[iLoginToClientPacketCommonCustomReportDetailsDetails].Value) + if err != nil { + return + } + } + return +} + +type LoginToClientPacketCommonRemoveResourcePack struct { + Uuid *uuid.UUID +} + +func (ret *LoginToClientPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) { + var LoginToClientPacketCommonRemoveResourcePackUuidPresent bool + err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonRemoveResourcePackUuidPresent) + if err != nil { + return + } + if LoginToClientPacketCommonRemoveResourcePackUuidPresent { + var LoginToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID + _, err = io.ReadFull(r, LoginToClientPacketCommonRemoveResourcePackUuidPresentValue[:]) + if err != nil { + return + } + ret.Uuid = &LoginToClientPacketCommonRemoveResourcePackUuidPresentValue + } + return +} +func (ret *LoginToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) + if err != nil { + return + } + if ret.Uuid != nil { + _, err = w.Write((*ret.Uuid)[:]) + if err != nil { + return + } + } + return +} + +type LoginToClientPacketCommonSelectKnownPacks struct { + Packs []struct { + Namespace string + Id string + Version string + } +} + +func (ret *LoginToClientPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) { + var lLoginToClientPacketCommonSelectKnownPacksPacks int32 + lLoginToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Packs = []struct { + Namespace string + Id string + Version string + }{} + for range lLoginToClientPacketCommonSelectKnownPacksPacks { + var LoginToClientPacketCommonSelectKnownPacksPacksElement struct { + Namespace string + Id string + Version string + } + LoginToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) + if err != nil { + return + } + LoginToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + LoginToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Packs = append(ret.Packs, LoginToClientPacketCommonSelectKnownPacksPacksElement) + } + return +} +func (ret *LoginToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) + if err != nil { + return + } + for iLoginToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { + err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Namespace) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Id) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iLoginToClientPacketCommonSelectKnownPacksPacks].Version) + if err != nil { + return + } + } + return +} + +type LoginToClientPacketCommonServerLinks struct { + Links []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } +} + +func (ret *LoginToClientPacketCommonServerLinks) Decode(r io.Reader) (err error) { + var lLoginToClientPacketCommonServerLinksLinks int32 + lLoginToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Links = []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + }{} + for range lLoginToClientPacketCommonServerLinksLinks { + var LoginToClientPacketCommonServerLinksLinksElement struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } + err = binary.Read(r, binary.BigEndian, &LoginToClientPacketCommonServerLinksLinksElement.HasKnownType) + if err != nil { + return + } + switch LoginToClientPacketCommonServerLinksLinksElement.HasKnownType { + case true: + var LoginToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType + err = LoginToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) + if err != nil { + return + } + LoginToClientPacketCommonServerLinksLinksElement.KnownType = LoginToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp + } + switch LoginToClientPacketCommonServerLinksLinksElement.HasKnownType { + case false: + var LoginToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon + err = LoginToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) + if err != nil { + return + } + LoginToClientPacketCommonServerLinksLinksElement.UnknownType = LoginToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp + } + LoginToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Links = append(ret.Links, LoginToClientPacketCommonServerLinksLinksElement) + } + return +} +func (ret *LoginToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) + if err != nil { + return + } + for iLoginToClientPacketCommonServerLinksLinks := range len(ret.Links) { + err = binary.Write(w, binary.BigEndian, ret.Links[iLoginToClientPacketCommonServerLinksLinks].HasKnownType) + if err != nil { + return + } + switch ret.Links[iLoginToClientPacketCommonServerLinksLinks].HasKnownType { + case true: + LoginToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iLoginToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToClientPacketCommonServerLinksLinksInnerKnownType.Encode(w) + if err != nil { + return + } + } + switch ret.Links[iLoginToClientPacketCommonServerLinksLinks].HasKnownType { + case false: + LoginToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iLoginToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = LoginToClientPacketCommonServerLinksLinksInnerUnknownType.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Links[iLoginToClientPacketCommonServerLinksLinks].Link) + if err != nil { + return + } + } + return +} + +type LoginToClientPacketCommonSettings struct { + Locale string + ViewDistance int8 + ChatFlags int32 + ChatColors bool + SkinParts uint8 + MainHand int32 + EnableTextFiltering bool + EnableServerListing bool + ParticleStatus string +} + +var LoginToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} + +func (ret *LoginToClientPacketCommonSettings) Decode(r io.Reader) (err error) { + ret.Locale, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ViewDistance) + if err != nil { + return + } + ret.ChatFlags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChatColors) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SkinParts) + if err != nil { + return + } + ret.MainHand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) + if err != nil { + return + } + var LoginToClientPacketCommonSettingsParticleStatusKey int32 + LoginToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ParticleStatus, err = proto_base.ErroringIndex(LoginToClientPacketCommonSettingsParticleStatusMap, LoginToClientPacketCommonSettingsParticleStatusKey) + if err != nil { + return + } + return +} + +var LoginToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} + +func (ret *LoginToClientPacketCommonSettings) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Locale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChatFlags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChatColors) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SkinParts) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.MainHand) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) + if err != nil { + return + } + var vLoginToClientPacketCommonSettingsParticleStatus int32 + vLoginToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(LoginToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vLoginToClientPacketCommonSettingsParticleStatus) + if err != nil { + return + } + return +} + +type LoginToClientPacketCommonStoreCookie struct { + Key string + Value ByteArray +} + +func (ret *LoginToClientPacketCommonStoreCookie) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Value.Decode(r) + if err != nil { + return + } + return +} +func (ret *LoginToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = ret.Value.Encode(w) + if err != nil { + return + } + return +} + +type LoginToClientPacketCommonTransfer struct { + Host string + Port int32 +} + +func (ret *LoginToClientPacketCommonTransfer) Decode(r io.Reader) (err error) { + ret.Host, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Port, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *LoginToClientPacketCommonTransfer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Host) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Port) + if err != nil { + return + } + return +} + +type LoginToClientPacketCompress struct { + Threshold int32 +} + +func (ret *LoginToClientPacketCompress) Decode(r io.Reader) (err error) { + ret.Threshold, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *LoginToClientPacketCompress) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.Threshold) + if err != nil { + return + } + return +} + +type LoginToClientPacketDisconnect struct { + Reason string +} + +func (ret *LoginToClientPacketDisconnect) Decode(r io.Reader) (err error) { + ret.Reason, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *LoginToClientPacketDisconnect) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Reason) + if err != nil { + return + } + return +} + +type LoginToClientPacketEncryptionBegin struct { + ServerId string + PublicKey []byte + VerifyToken []byte + ShouldAuthenticate bool +} + +func (ret *LoginToClientPacketEncryptionBegin) Decode(r io.Reader) (err error) { + ret.ServerId, err = proto_base.DecodeString(r) + if err != nil { + return + } + var lLoginToClientPacketEncryptionBeginPublicKey int32 + lLoginToClientPacketEncryptionBeginPublicKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.PublicKey, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginPublicKey))) + if err != nil { + return + } + var lLoginToClientPacketEncryptionBeginVerifyToken int32 + lLoginToClientPacketEncryptionBeginVerifyToken, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.VerifyToken, err = io.ReadAll(io.LimitReader(r, int64(lLoginToClientPacketEncryptionBeginVerifyToken))) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ShouldAuthenticate) + if err != nil { + return + } + return +} +func (ret *LoginToClientPacketEncryptionBegin) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.ServerId) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.PublicKey))) + if err != nil { + return + } + _, err = w.Write(ret.PublicKey) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.VerifyToken))) + if err != nil { + return + } + _, err = w.Write(ret.VerifyToken) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ShouldAuthenticate) + if err != nil { + return + } + return +} + +type LoginToClientPacketLoginPluginRequest struct { + MessageId int32 + Channel string + Data proto_base.RestBuffer +} + +func (ret *LoginToClientPacketLoginPluginRequest) Decode(r io.Reader) (err error) { + ret.MessageId, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Channel, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Data.Decode(r) + if err != nil { + return + } + return +} +func (ret *LoginToClientPacketLoginPluginRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, ret.MessageId) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Channel) + if err != nil { + return + } + err = ret.Data.Encode(w) + if err != nil { + return + } + return +} + +type LoginToClientPacketSuccess struct { + Uuid uuid.UUID + Username string + Properties []struct { + Name string + Value string + Signature *string + } +} + +func (ret *LoginToClientPacketSuccess) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Username, err = proto_base.DecodeString(r) + if err != nil { + return + } + var lLoginToClientPacketSuccessProperties int32 + lLoginToClientPacketSuccessProperties, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Properties = []struct { + Name string + Value string + Signature *string + }{} + for range lLoginToClientPacketSuccessProperties { + var LoginToClientPacketSuccessPropertiesElement struct { + Name string + Value string + Signature *string + } + LoginToClientPacketSuccessPropertiesElement.Name, err = proto_base.DecodeString(r) + if err != nil { + return + } + LoginToClientPacketSuccessPropertiesElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + var LoginToClientPacketSuccessPropertiesElementSignaturePresent bool + err = binary.Read(r, binary.BigEndian, &LoginToClientPacketSuccessPropertiesElementSignaturePresent) + if err != nil { + return + } + if LoginToClientPacketSuccessPropertiesElementSignaturePresent { + var LoginToClientPacketSuccessPropertiesElementSignaturePresentValue string + LoginToClientPacketSuccessPropertiesElementSignaturePresentValue, err = proto_base.DecodeString(r) + if err != nil { + return + } + LoginToClientPacketSuccessPropertiesElement.Signature = &LoginToClientPacketSuccessPropertiesElementSignaturePresentValue + } + ret.Properties = append(ret.Properties, LoginToClientPacketSuccessPropertiesElement) + } + return +} +func (ret *LoginToClientPacketSuccess) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Username) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Properties))) + if err != nil { + return + } + for iLoginToClientPacketSuccessProperties := range len(ret.Properties) { + err = proto_base.EncodeString(w, ret.Properties[iLoginToClientPacketSuccessProperties].Name) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Properties[iLoginToClientPacketSuccessProperties].Value) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Properties[iLoginToClientPacketSuccessProperties].Signature != nil) + if err != nil { + return + } + if ret.Properties[iLoginToClientPacketSuccessProperties].Signature != nil { + err = proto_base.EncodeString(w, *ret.Properties[iLoginToClientPacketSuccessProperties].Signature) + if err != nil { + return + } + } + } + return +} + +type ConfigurationToServerPacket struct { + Name string + Params any +} + +var ConfigurationToServerPacketNameMap = map[int32]string{0x00: "settings", 0x01: "cookie_response", 0x02: "custom_payload", 0x03: "finish_configuration", 0x04: "keep_alive", 0x05: "pong", 0x06: "resource_pack_receive", 0x07: "select_known_packs", 0x08: "custom_click_action"} + +func (ret *ConfigurationToServerPacket) Decode(r io.Reader) (err error) { + var ConfigurationToServerPacketNameKey int32 + ConfigurationToServerPacketNameKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.ErroringIndex(ConfigurationToServerPacketNameMap, ConfigurationToServerPacketNameKey) + if err != nil { + return + } + switch ret.Name { + case "cookie_response": + var ConfigurationToServerPacketParamsCookieResponseTmp ConfigurationToServerPacketCommonCookieResponse + err = ConfigurationToServerPacketParamsCookieResponseTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToServerPacketParamsCookieResponseTmp + case "custom_click_action": + var ConfigurationToServerPacketParamsCustomClickActionTmp ConfigurationToServerPacketCommonCustomClickAction + err = ConfigurationToServerPacketParamsCustomClickActionTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToServerPacketParamsCustomClickActionTmp + case "custom_payload": + var ConfigurationToServerPacketParamsCustomPayloadTmp ConfigurationToServerPacketCustomPayload + err = ConfigurationToServerPacketParamsCustomPayloadTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToServerPacketParamsCustomPayloadTmp + case "finish_configuration": + var ConfigurationToServerPacketParamsFinishConfigurationTmp ConfigurationToServerPacketFinishConfiguration + err = ConfigurationToServerPacketParamsFinishConfigurationTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToServerPacketParamsFinishConfigurationTmp + case "keep_alive": + var ConfigurationToServerPacketParamsKeepAliveTmp ConfigurationToServerPacketKeepAlive + err = ConfigurationToServerPacketParamsKeepAliveTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToServerPacketParamsKeepAliveTmp + case "pong": + var ConfigurationToServerPacketParamsPongTmp ConfigurationToServerPacketPong + err = ConfigurationToServerPacketParamsPongTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToServerPacketParamsPongTmp + case "resource_pack_receive": + var ConfigurationToServerPacketParamsResourcePackReceiveTmp ConfigurationToServerPacketResourcePackReceive + err = ConfigurationToServerPacketParamsResourcePackReceiveTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToServerPacketParamsResourcePackReceiveTmp + case "select_known_packs": + var ConfigurationToServerPacketParamsSelectKnownPacksTmp ConfigurationToServerPacketCommonSelectKnownPacks + err = ConfigurationToServerPacketParamsSelectKnownPacksTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToServerPacketParamsSelectKnownPacksTmp + case "settings": + var ConfigurationToServerPacketParamsSettingsTmp ConfigurationToServerPacketCommonSettings + err = ConfigurationToServerPacketParamsSettingsTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToServerPacketParamsSettingsTmp + } + return +} + +var ConfigurationToServerPacketNameReverseMap = map[string]int32{"settings": 0x00, "cookie_response": 0x01, "custom_payload": 0x02, "finish_configuration": 0x03, "keep_alive": 0x04, "pong": 0x05, "resource_pack_receive": 0x06, "select_known_packs": 0x07, "custom_click_action": 0x08} + +func (ret *ConfigurationToServerPacket) Encode(w io.Writer) (err error) { + var vConfigurationToServerPacketName int32 + vConfigurationToServerPacketName, err = proto_base.ErroringIndex(ConfigurationToServerPacketNameReverseMap, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vConfigurationToServerPacketName) + if err != nil { + return + } + switch ret.Name { + case "cookie_response": + ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonCookieResponse) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketParams.Encode(w) + if err != nil { + return + } + case "custom_click_action": + ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonCustomClickAction) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketParams.Encode(w) + if err != nil { + return + } + case "custom_payload": + ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCustomPayload) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketParams.Encode(w) + if err != nil { + return + } + case "finish_configuration": + ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketFinishConfiguration) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketParams.Encode(w) + if err != nil { + return + } + case "keep_alive": + ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketKeepAlive) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketParams.Encode(w) + if err != nil { + return + } + case "pong": + ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketPong) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketParams.Encode(w) + if err != nil { + return + } + case "resource_pack_receive": + ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketResourcePackReceive) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketParams.Encode(w) + if err != nil { + return + } + case "select_known_packs": + ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonSelectKnownPacks) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketParams.Encode(w) + if err != nil { + return + } + case "settings": + ConfigurationToServerPacketParams, ok := ret.Params.(ConfigurationToServerPacketCommonSettings) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketParams.Encode(w) + if err != nil { + return + } + } + return +} + +type ConfigurationToServerPacketCommonAddResourcePack struct { + Uuid uuid.UUID + Url string + Hash string + Forced bool + PromptMessage *nbt.Anon +} + +func (ret *ConfigurationToServerPacketCommonAddResourcePack) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Url, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Hash, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Forced) + if err != nil { + return + } + var ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent bool + err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent) + if err != nil { + return + } + if ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresent { + var ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon + err = ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.PromptMessage = &ConfigurationToServerPacketCommonAddResourcePackPromptMessagePresentValue + } + return +} +func (ret *ConfigurationToServerPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Url) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Hash) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Forced) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) + if err != nil { + return + } + if ret.PromptMessage != nil { + err = (*ret.PromptMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type ConfigurationToServerPacketCommonClearDialog struct { +} + +func (ret *ConfigurationToServerPacketCommonClearDialog) Decode(r io.Reader) (err error) { + return +} +func (ret *ConfigurationToServerPacketCommonClearDialog) Encode(w io.Writer) (err error) { + return +} + +type ConfigurationToServerPacketCommonCookieRequest struct { + Cookie string +} + +func (ret *ConfigurationToServerPacketCommonCookieRequest) Decode(r io.Reader) (err error) { + ret.Cookie, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToServerPacketCommonCookieRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Cookie) + if err != nil { + return + } + return +} + +type ConfigurationToServerPacketCommonCookieResponse struct { + Key string + Value *ByteArray +} + +func (ret *ConfigurationToServerPacketCommonCookieResponse) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var ConfigurationToServerPacketCommonCookieResponseValuePresent bool + err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonCookieResponseValuePresent) + if err != nil { + return + } + if ConfigurationToServerPacketCommonCookieResponseValuePresent { + var ConfigurationToServerPacketCommonCookieResponseValuePresentValue ByteArray + err = ConfigurationToServerPacketCommonCookieResponseValuePresentValue.Decode(r) + if err != nil { + return + } + ret.Value = &ConfigurationToServerPacketCommonCookieResponseValuePresentValue + } + return +} +func (ret *ConfigurationToServerPacketCommonCookieResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value != nil) + if err != nil { + return + } + if ret.Value != nil { + err = (*ret.Value).Encode(w) + if err != nil { + return + } + } + return +} + +type ConfigurationToServerPacketCommonCustomClickAction struct { + Id string + Nbt *nbt.Anon +} + +func (ret *ConfigurationToServerPacketCommonCustomClickAction) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var ConfigurationToServerPacketCommonCustomClickActionNbtPresent bool + err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonCustomClickActionNbtPresent) + if err != nil { + return + } + if ConfigurationToServerPacketCommonCustomClickActionNbtPresent { + var ConfigurationToServerPacketCommonCustomClickActionNbtPresentValue nbt.Anon + err = ConfigurationToServerPacketCommonCustomClickActionNbtPresentValue.Decode(r) + if err != nil { + return + } + ret.Nbt = &ConfigurationToServerPacketCommonCustomClickActionNbtPresentValue + } + return +} +func (ret *ConfigurationToServerPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) + if err != nil { + return + } + if ret.Nbt != nil { + err = (*ret.Nbt).Encode(w) + if err != nil { + return + } + } + return +} + +type ConfigurationToServerPacketCommonCustomReportDetails struct { + Details []struct { + Key string + Value string + } +} + +func (ret *ConfigurationToServerPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) { + var lConfigurationToServerPacketCommonCustomReportDetailsDetails int32 + lConfigurationToServerPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Details = []struct { + Key string + Value string + }{} + for range lConfigurationToServerPacketCommonCustomReportDetailsDetails { + var ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement struct { + Key string + Value string + } + ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Details = append(ret.Details, ConfigurationToServerPacketCommonCustomReportDetailsDetailsElement) + } + return +} +func (ret *ConfigurationToServerPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) + if err != nil { + return + } + for iConfigurationToServerPacketCommonCustomReportDetailsDetails := range len(ret.Details) { + err = proto_base.EncodeString(w, ret.Details[iConfigurationToServerPacketCommonCustomReportDetailsDetails].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Details[iConfigurationToServerPacketCommonCustomReportDetailsDetails].Value) + if err != nil { + return + } + } + return +} + +type ConfigurationToServerPacketCommonRemoveResourcePack struct { + Uuid *uuid.UUID +} + +func (ret *ConfigurationToServerPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) { + var ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent bool + err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent) + if err != nil { + return + } + if ConfigurationToServerPacketCommonRemoveResourcePackUuidPresent { + var ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID + _, err = io.ReadFull(r, ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue[:]) + if err != nil { + return + } + ret.Uuid = &ConfigurationToServerPacketCommonRemoveResourcePackUuidPresentValue + } + return +} +func (ret *ConfigurationToServerPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) + if err != nil { + return + } + if ret.Uuid != nil { + _, err = w.Write((*ret.Uuid)[:]) + if err != nil { + return + } + } + return +} + +type ConfigurationToServerPacketCommonSelectKnownPacks struct { + Packs []struct { + Namespace string + Id string + Version string + } +} + +func (ret *ConfigurationToServerPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) { + var lConfigurationToServerPacketCommonSelectKnownPacksPacks int32 + lConfigurationToServerPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Packs = []struct { + Namespace string + Id string + Version string + }{} + for range lConfigurationToServerPacketCommonSelectKnownPacksPacks { + var ConfigurationToServerPacketCommonSelectKnownPacksPacksElement struct { + Namespace string + Id string + Version string + } + ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) + if err != nil { + return + } + ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + ConfigurationToServerPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Packs = append(ret.Packs, ConfigurationToServerPacketCommonSelectKnownPacksPacksElement) + } + return +} +func (ret *ConfigurationToServerPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) + if err != nil { + return + } + for iConfigurationToServerPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { + err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Namespace) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Id) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iConfigurationToServerPacketCommonSelectKnownPacksPacks].Version) + if err != nil { + return + } + } + return +} + +type ConfigurationToServerPacketCommonServerLinks struct { + Links []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } +} + +func (ret *ConfigurationToServerPacketCommonServerLinks) Decode(r io.Reader) (err error) { + var lConfigurationToServerPacketCommonServerLinksLinks int32 + lConfigurationToServerPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Links = []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + }{} + for range lConfigurationToServerPacketCommonServerLinksLinks { + var ConfigurationToServerPacketCommonServerLinksLinksElement struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } + err = binary.Read(r, binary.BigEndian, &ConfigurationToServerPacketCommonServerLinksLinksElement.HasKnownType) + if err != nil { + return + } + switch ConfigurationToServerPacketCommonServerLinksLinksElement.HasKnownType { + case true: + var ConfigurationToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType + err = ConfigurationToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) + if err != nil { + return + } + ConfigurationToServerPacketCommonServerLinksLinksElement.KnownType = ConfigurationToServerPacketCommonServerLinksLinksElementKnownTypeTrueTmp + } + switch ConfigurationToServerPacketCommonServerLinksLinksElement.HasKnownType { + case false: + var ConfigurationToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon + err = ConfigurationToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) + if err != nil { + return + } + ConfigurationToServerPacketCommonServerLinksLinksElement.UnknownType = ConfigurationToServerPacketCommonServerLinksLinksElementUnknownTypeFalseTmp + } + ConfigurationToServerPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Links = append(ret.Links, ConfigurationToServerPacketCommonServerLinksLinksElement) + } + return +} +func (ret *ConfigurationToServerPacketCommonServerLinks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) + if err != nil { + return + } + for iConfigurationToServerPacketCommonServerLinksLinks := range len(ret.Links) { + err = binary.Write(w, binary.BigEndian, ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].HasKnownType) + if err != nil { + return + } + switch ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].HasKnownType { + case true: + ConfigurationToServerPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].KnownType.(ServerLinkType) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketCommonServerLinksLinksInnerKnownType.Encode(w) + if err != nil { + return + } + } + switch ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].HasKnownType { + case false: + ConfigurationToServerPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToServerPacketCommonServerLinksLinksInnerUnknownType.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Links[iConfigurationToServerPacketCommonServerLinksLinks].Link) + if err != nil { + return + } + } + return +} + +type ConfigurationToServerPacketCommonSettings struct { + Locale string + ViewDistance int8 + ChatFlags int32 + ChatColors bool + SkinParts uint8 + MainHand int32 + EnableTextFiltering bool + EnableServerListing bool + ParticleStatus string +} + +var ConfigurationToServerPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} + +func (ret *ConfigurationToServerPacketCommonSettings) Decode(r io.Reader) (err error) { + ret.Locale, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ViewDistance) + if err != nil { + return + } + ret.ChatFlags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChatColors) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SkinParts) + if err != nil { + return + } + ret.MainHand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) + if err != nil { + return + } + var ConfigurationToServerPacketCommonSettingsParticleStatusKey int32 + ConfigurationToServerPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ParticleStatus, err = proto_base.ErroringIndex(ConfigurationToServerPacketCommonSettingsParticleStatusMap, ConfigurationToServerPacketCommonSettingsParticleStatusKey) + if err != nil { + return + } + return +} + +var ConfigurationToServerPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} + +func (ret *ConfigurationToServerPacketCommonSettings) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Locale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChatFlags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChatColors) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SkinParts) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.MainHand) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) + if err != nil { + return + } + var vConfigurationToServerPacketCommonSettingsParticleStatus int32 + vConfigurationToServerPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(ConfigurationToServerPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vConfigurationToServerPacketCommonSettingsParticleStatus) + if err != nil { + return + } + return +} + +type ConfigurationToServerPacketCommonStoreCookie struct { + Key string + Value ByteArray +} + +func (ret *ConfigurationToServerPacketCommonStoreCookie) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Value.Decode(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToServerPacketCommonStoreCookie) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = ret.Value.Encode(w) + if err != nil { + return + } + return +} + +type ConfigurationToServerPacketCommonTransfer struct { + Host string + Port int32 +} + +func (ret *ConfigurationToServerPacketCommonTransfer) Decode(r io.Reader) (err error) { + ret.Host, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Port, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToServerPacketCommonTransfer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Host) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Port) + if err != nil { + return + } + return +} + +type ConfigurationToServerPacketCustomPayload struct { + Channel string + Data proto_base.RestBuffer +} + +func (ret *ConfigurationToServerPacketCustomPayload) Decode(r io.Reader) (err error) { + ret.Channel, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Data.Decode(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToServerPacketCustomPayload) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Channel) + if err != nil { + return + } + err = ret.Data.Encode(w) + if err != nil { + return + } + return +} + +type ConfigurationToServerPacketFinishConfiguration struct { +} + +func (ret *ConfigurationToServerPacketFinishConfiguration) Decode(r io.Reader) (err error) { + return +} +func (ret *ConfigurationToServerPacketFinishConfiguration) Encode(w io.Writer) (err error) { + return +} + +type ConfigurationToServerPacketKeepAlive struct { + KeepAliveId int64 +} + +func (ret *ConfigurationToServerPacketKeepAlive) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId) + if err != nil { + return + } + return +} +func (ret *ConfigurationToServerPacketKeepAlive) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.KeepAliveId) + if err != nil { + return + } + return +} + +type ConfigurationToServerPacketPong struct { + Id int32 +} + +func (ret *ConfigurationToServerPacketPong) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Id) + if err != nil { + return + } + return +} +func (ret *ConfigurationToServerPacketPong) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Id) + if err != nil { + return + } + return +} + +type ConfigurationToServerPacketResourcePackReceive struct { + Uuid uuid.UUID + Result int32 +} + +func (ret *ConfigurationToServerPacketResourcePackReceive) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Result, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToServerPacketResourcePackReceive) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Result) + if err != nil { + return + } + return +} + +type ConfigurationToClientPacket struct { + Name string + Params any +} + +var ConfigurationToClientPacketNameMap = map[int32]string{0x00: "cookie_request", 0x01: "custom_payload", 0x02: "disconnect", 0x03: "finish_configuration", 0x04: "keep_alive", 0x05: "ping", 0x06: "reset_chat", 0x07: "registry_data", 0x08: "remove_resource_pack", 0x09: "add_resource_pack", 0x0a: "store_cookie", 0x0b: "transfer", 0x0c: "feature_flags", 0x0d: "tags", 0x0e: "select_known_packs", 0x0f: "custom_report_details", 0x10: "server_links", 0x11: "clear_dialog", 0x12: "show_dialog"} + +func (ret *ConfigurationToClientPacket) Decode(r io.Reader) (err error) { + var ConfigurationToClientPacketNameKey int32 + ConfigurationToClientPacketNameKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Name, err = proto_base.ErroringIndex(ConfigurationToClientPacketNameMap, ConfigurationToClientPacketNameKey) + if err != nil { + return + } + switch ret.Name { + case "add_resource_pack": + var ConfigurationToClientPacketParamsAddResourcePackTmp ConfigurationToClientPacketCommonAddResourcePack + err = ConfigurationToClientPacketParamsAddResourcePackTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsAddResourcePackTmp + case "clear_dialog": + var ConfigurationToClientPacketParamsClearDialogTmp ConfigurationToClientPacketCommonClearDialog + err = ConfigurationToClientPacketParamsClearDialogTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsClearDialogTmp + case "cookie_request": + var ConfigurationToClientPacketParamsCookieRequestTmp ConfigurationToClientPacketCommonCookieRequest + err = ConfigurationToClientPacketParamsCookieRequestTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsCookieRequestTmp + case "custom_payload": + var ConfigurationToClientPacketParamsCustomPayloadTmp ConfigurationToClientPacketCustomPayload + err = ConfigurationToClientPacketParamsCustomPayloadTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsCustomPayloadTmp + case "custom_report_details": + var ConfigurationToClientPacketParamsCustomReportDetailsTmp ConfigurationToClientPacketCommonCustomReportDetails + err = ConfigurationToClientPacketParamsCustomReportDetailsTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsCustomReportDetailsTmp + case "disconnect": + var ConfigurationToClientPacketParamsDisconnectTmp ConfigurationToClientPacketDisconnect + err = ConfigurationToClientPacketParamsDisconnectTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsDisconnectTmp + case "feature_flags": + var ConfigurationToClientPacketParamsFeatureFlagsTmp ConfigurationToClientPacketFeatureFlags + err = ConfigurationToClientPacketParamsFeatureFlagsTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsFeatureFlagsTmp + case "finish_configuration": + var ConfigurationToClientPacketParamsFinishConfigurationTmp ConfigurationToClientPacketFinishConfiguration + err = ConfigurationToClientPacketParamsFinishConfigurationTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsFinishConfigurationTmp + case "keep_alive": + var ConfigurationToClientPacketParamsKeepAliveTmp ConfigurationToClientPacketKeepAlive + err = ConfigurationToClientPacketParamsKeepAliveTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsKeepAliveTmp + case "ping": + var ConfigurationToClientPacketParamsPingTmp ConfigurationToClientPacketPing + err = ConfigurationToClientPacketParamsPingTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsPingTmp + case "registry_data": + var ConfigurationToClientPacketParamsRegistryDataTmp ConfigurationToClientPacketRegistryData + err = ConfigurationToClientPacketParamsRegistryDataTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsRegistryDataTmp + case "remove_resource_pack": + var ConfigurationToClientPacketParamsRemoveResourcePackTmp ConfigurationToClientPacketCommonRemoveResourcePack + err = ConfigurationToClientPacketParamsRemoveResourcePackTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsRemoveResourcePackTmp + case "reset_chat": + var ConfigurationToClientPacketParamsResetChatTmp ConfigurationToClientPacketResetChat + err = ConfigurationToClientPacketParamsResetChatTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsResetChatTmp + case "select_known_packs": + var ConfigurationToClientPacketParamsSelectKnownPacksTmp ConfigurationToClientPacketCommonSelectKnownPacks + err = ConfigurationToClientPacketParamsSelectKnownPacksTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsSelectKnownPacksTmp + case "server_links": + var ConfigurationToClientPacketParamsServerLinksTmp ConfigurationToClientPacketCommonServerLinks + err = ConfigurationToClientPacketParamsServerLinksTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsServerLinksTmp + case "show_dialog": + var ConfigurationToClientPacketParamsShowDialogTmp ConfigurationToClientPacketShowDialog + err = ConfigurationToClientPacketParamsShowDialogTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsShowDialogTmp + case "store_cookie": + var ConfigurationToClientPacketParamsStoreCookieTmp ConfigurationToClientPacketCommonStoreCookie + err = ConfigurationToClientPacketParamsStoreCookieTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsStoreCookieTmp + case "tags": + var ConfigurationToClientPacketParamsTagsTmp ConfigurationToClientPacketTags + err = ConfigurationToClientPacketParamsTagsTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsTagsTmp + case "transfer": + var ConfigurationToClientPacketParamsTransferTmp ConfigurationToClientPacketCommonTransfer + err = ConfigurationToClientPacketParamsTransferTmp.Decode(r) + if err != nil { + return + } + ret.Params = ConfigurationToClientPacketParamsTransferTmp + } + return +} + +var ConfigurationToClientPacketNameReverseMap = map[string]int32{"cookie_request": 0x00, "custom_payload": 0x01, "disconnect": 0x02, "finish_configuration": 0x03, "keep_alive": 0x04, "ping": 0x05, "reset_chat": 0x06, "registry_data": 0x07, "remove_resource_pack": 0x08, "add_resource_pack": 0x09, "store_cookie": 0x0a, "transfer": 0x0b, "feature_flags": 0x0c, "tags": 0x0d, "select_known_packs": 0x0e, "custom_report_details": 0x0f, "server_links": 0x10, "clear_dialog": 0x11, "show_dialog": 0x12} + +func (ret *ConfigurationToClientPacket) Encode(w io.Writer) (err error) { + var vConfigurationToClientPacketName int32 + vConfigurationToClientPacketName, err = proto_base.ErroringIndex(ConfigurationToClientPacketNameReverseMap, ret.Name) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vConfigurationToClientPacketName) + if err != nil { + return + } + switch ret.Name { + case "add_resource_pack": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonAddResourcePack) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "clear_dialog": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonClearDialog) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "cookie_request": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonCookieRequest) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "custom_payload": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCustomPayload) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "custom_report_details": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonCustomReportDetails) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "disconnect": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketDisconnect) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "feature_flags": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketFeatureFlags) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "finish_configuration": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketFinishConfiguration) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "keep_alive": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketKeepAlive) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "ping": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketPing) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "registry_data": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketRegistryData) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "remove_resource_pack": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonRemoveResourcePack) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "reset_chat": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketResetChat) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "select_known_packs": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonSelectKnownPacks) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "server_links": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonServerLinks) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "show_dialog": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketShowDialog) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "store_cookie": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonStoreCookie) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "tags": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketTags) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + case "transfer": + ConfigurationToClientPacketParams, ok := ret.Params.(ConfigurationToClientPacketCommonTransfer) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketParams.Encode(w) + if err != nil { + return + } + } + return +} + +type ConfigurationToClientPacketCommonAddResourcePack struct { + Uuid uuid.UUID + Url string + Hash string + Forced bool + PromptMessage *nbt.Anon +} + +func (ret *ConfigurationToClientPacketCommonAddResourcePack) Decode(r io.Reader) (err error) { + _, err = io.ReadFull(r, ret.Uuid[:]) + if err != nil { + return + } + ret.Url, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Hash, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.Forced) + if err != nil { + return + } + var ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent bool + err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent) + if err != nil { + return + } + if ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresent { + var ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue nbt.Anon + err = ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue.Decode(r) + if err != nil { + return + } + ret.PromptMessage = &ConfigurationToClientPacketCommonAddResourcePackPromptMessagePresentValue + } + return +} +func (ret *ConfigurationToClientPacketCommonAddResourcePack) Encode(w io.Writer) (err error) { + _, err = w.Write(ret.Uuid[:]) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Url) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Hash) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Forced) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.PromptMessage != nil) + if err != nil { + return + } + if ret.PromptMessage != nil { + err = (*ret.PromptMessage).Encode(w) + if err != nil { + return + } + } + return +} + +type ConfigurationToClientPacketCommonClearDialog struct { +} + +func (ret *ConfigurationToClientPacketCommonClearDialog) Decode(r io.Reader) (err error) { + return +} +func (ret *ConfigurationToClientPacketCommonClearDialog) Encode(w io.Writer) (err error) { + return +} + +type ConfigurationToClientPacketCommonCookieRequest struct { + Cookie string +} + +func (ret *ConfigurationToClientPacketCommonCookieRequest) Decode(r io.Reader) (err error) { + ret.Cookie, err = proto_base.DecodeString(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToClientPacketCommonCookieRequest) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Cookie) + if err != nil { + return + } + return +} + +type ConfigurationToClientPacketCommonCookieResponse struct { + Key string + Value *ByteArray +} + +func (ret *ConfigurationToClientPacketCommonCookieResponse) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var ConfigurationToClientPacketCommonCookieResponseValuePresent bool + err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonCookieResponseValuePresent) + if err != nil { + return + } + if ConfigurationToClientPacketCommonCookieResponseValuePresent { + var ConfigurationToClientPacketCommonCookieResponseValuePresentValue ByteArray + err = ConfigurationToClientPacketCommonCookieResponseValuePresentValue.Decode(r) + if err != nil { + return + } + ret.Value = &ConfigurationToClientPacketCommonCookieResponseValuePresentValue + } + return +} +func (ret *ConfigurationToClientPacketCommonCookieResponse) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Value != nil) + if err != nil { + return + } + if ret.Value != nil { + err = (*ret.Value).Encode(w) + if err != nil { + return + } + } + return +} + +type ConfigurationToClientPacketCommonCustomClickAction struct { + Id string + Nbt *nbt.Anon +} + +func (ret *ConfigurationToClientPacketCommonCustomClickAction) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var ConfigurationToClientPacketCommonCustomClickActionNbtPresent bool + err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonCustomClickActionNbtPresent) + if err != nil { + return + } + if ConfigurationToClientPacketCommonCustomClickActionNbtPresent { + var ConfigurationToClientPacketCommonCustomClickActionNbtPresentValue nbt.Anon + err = ConfigurationToClientPacketCommonCustomClickActionNbtPresentValue.Decode(r) + if err != nil { + return + } + ret.Nbt = &ConfigurationToClientPacketCommonCustomClickActionNbtPresentValue + } + return +} +func (ret *ConfigurationToClientPacketCommonCustomClickAction) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Nbt != nil) + if err != nil { + return + } + if ret.Nbt != nil { + err = (*ret.Nbt).Encode(w) + if err != nil { + return + } + } + return +} + +type ConfigurationToClientPacketCommonCustomReportDetails struct { + Details []struct { + Key string + Value string + } +} + +func (ret *ConfigurationToClientPacketCommonCustomReportDetails) Decode(r io.Reader) (err error) { + var lConfigurationToClientPacketCommonCustomReportDetailsDetails int32 + lConfigurationToClientPacketCommonCustomReportDetailsDetails, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Details = []struct { + Key string + Value string + }{} + for range lConfigurationToClientPacketCommonCustomReportDetailsDetails { + var ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement struct { + Key string + Value string + } + ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement.Value, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Details = append(ret.Details, ConfigurationToClientPacketCommonCustomReportDetailsDetailsElement) + } + return +} +func (ret *ConfigurationToClientPacketCommonCustomReportDetails) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Details))) + if err != nil { + return + } + for iConfigurationToClientPacketCommonCustomReportDetailsDetails := range len(ret.Details) { + err = proto_base.EncodeString(w, ret.Details[iConfigurationToClientPacketCommonCustomReportDetailsDetails].Key) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Details[iConfigurationToClientPacketCommonCustomReportDetailsDetails].Value) + if err != nil { + return + } + } + return +} + +type ConfigurationToClientPacketCommonRemoveResourcePack struct { + Uuid *uuid.UUID +} + +func (ret *ConfigurationToClientPacketCommonRemoveResourcePack) Decode(r io.Reader) (err error) { + var ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent bool + err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent) + if err != nil { + return + } + if ConfigurationToClientPacketCommonRemoveResourcePackUuidPresent { + var ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue uuid.UUID + _, err = io.ReadFull(r, ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue[:]) + if err != nil { + return + } + ret.Uuid = &ConfigurationToClientPacketCommonRemoveResourcePackUuidPresentValue + } + return +} +func (ret *ConfigurationToClientPacketCommonRemoveResourcePack) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Uuid != nil) + if err != nil { + return + } + if ret.Uuid != nil { + _, err = w.Write((*ret.Uuid)[:]) + if err != nil { + return + } + } + return +} + +type ConfigurationToClientPacketCommonSelectKnownPacks struct { + Packs []struct { + Namespace string + Id string + Version string + } +} + +func (ret *ConfigurationToClientPacketCommonSelectKnownPacks) Decode(r io.Reader) (err error) { + var lConfigurationToClientPacketCommonSelectKnownPacksPacks int32 + lConfigurationToClientPacketCommonSelectKnownPacksPacks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Packs = []struct { + Namespace string + Id string + Version string + }{} + for range lConfigurationToClientPacketCommonSelectKnownPacksPacks { + var ConfigurationToClientPacketCommonSelectKnownPacksPacksElement struct { + Namespace string + Id string + Version string + } + ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Namespace, err = proto_base.DecodeString(r) + if err != nil { + return + } + ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + ConfigurationToClientPacketCommonSelectKnownPacksPacksElement.Version, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Packs = append(ret.Packs, ConfigurationToClientPacketCommonSelectKnownPacksPacksElement) + } + return +} +func (ret *ConfigurationToClientPacketCommonSelectKnownPacks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Packs))) + if err != nil { + return + } + for iConfigurationToClientPacketCommonSelectKnownPacksPacks := range len(ret.Packs) { + err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Namespace) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Id) + if err != nil { + return + } + err = proto_base.EncodeString(w, ret.Packs[iConfigurationToClientPacketCommonSelectKnownPacksPacks].Version) + if err != nil { + return + } + } + return +} + +type ConfigurationToClientPacketCommonServerLinks struct { + Links []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } +} + +func (ret *ConfigurationToClientPacketCommonServerLinks) Decode(r io.Reader) (err error) { + var lConfigurationToClientPacketCommonServerLinksLinks int32 + lConfigurationToClientPacketCommonServerLinksLinks, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Links = []struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + }{} + for range lConfigurationToClientPacketCommonServerLinksLinks { + var ConfigurationToClientPacketCommonServerLinksLinksElement struct { + HasKnownType bool + KnownType any + UnknownType any + Link string + } + err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketCommonServerLinksLinksElement.HasKnownType) + if err != nil { + return + } + switch ConfigurationToClientPacketCommonServerLinksLinksElement.HasKnownType { + case true: + var ConfigurationToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp ServerLinkType + err = ConfigurationToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp.Decode(r) + if err != nil { + return + } + ConfigurationToClientPacketCommonServerLinksLinksElement.KnownType = ConfigurationToClientPacketCommonServerLinksLinksElementKnownTypeTrueTmp + } + switch ConfigurationToClientPacketCommonServerLinksLinksElement.HasKnownType { + case false: + var ConfigurationToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp nbt.Anon + err = ConfigurationToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp.Decode(r) + if err != nil { + return + } + ConfigurationToClientPacketCommonServerLinksLinksElement.UnknownType = ConfigurationToClientPacketCommonServerLinksLinksElementUnknownTypeFalseTmp + } + ConfigurationToClientPacketCommonServerLinksLinksElement.Link, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Links = append(ret.Links, ConfigurationToClientPacketCommonServerLinksLinksElement) + } + return +} +func (ret *ConfigurationToClientPacketCommonServerLinks) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Links))) + if err != nil { + return + } + for iConfigurationToClientPacketCommonServerLinksLinks := range len(ret.Links) { + err = binary.Write(w, binary.BigEndian, ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].HasKnownType) + if err != nil { + return + } + switch ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].HasKnownType { + case true: + ConfigurationToClientPacketCommonServerLinksLinksInnerKnownType, ok := ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].KnownType.(ServerLinkType) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketCommonServerLinksLinksInnerKnownType.Encode(w) + if err != nil { + return + } + } + switch ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].HasKnownType { + case false: + ConfigurationToClientPacketCommonServerLinksLinksInnerUnknownType, ok := ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].UnknownType.(nbt.Anon) + if !ok { + err = proto_base.BadTypeError + return + } + err = ConfigurationToClientPacketCommonServerLinksLinksInnerUnknownType.Encode(w) + if err != nil { + return + } + } + err = proto_base.EncodeString(w, ret.Links[iConfigurationToClientPacketCommonServerLinksLinks].Link) + if err != nil { + return + } + } + return +} + +type ConfigurationToClientPacketCommonSettings struct { + Locale string + ViewDistance int8 + ChatFlags int32 + ChatColors bool + SkinParts uint8 + MainHand int32 + EnableTextFiltering bool + EnableServerListing bool + ParticleStatus string +} + +var ConfigurationToClientPacketCommonSettingsParticleStatusMap = map[int32]string{0: "all", 1: "decreased", 2: "minimal"} + +func (ret *ConfigurationToClientPacketCommonSettings) Decode(r io.Reader) (err error) { + ret.Locale, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ViewDistance) + if err != nil { + return + } + ret.ChatFlags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.ChatColors) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.SkinParts) + if err != nil { + return + } + ret.MainHand, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Read(r, binary.BigEndian, &ret.EnableServerListing) + if err != nil { + return + } + var ConfigurationToClientPacketCommonSettingsParticleStatusKey int32 + ConfigurationToClientPacketCommonSettingsParticleStatusKey, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.ParticleStatus, err = proto_base.ErroringIndex(ConfigurationToClientPacketCommonSettingsParticleStatusMap, ConfigurationToClientPacketCommonSettingsParticleStatusKey) + if err != nil { + return + } + return +} + +var ConfigurationToClientPacketCommonSettingsParticleStatusReverseMap = map[string]int32{"all": 0, "decreased": 1, "minimal": 2} + +func (ret *ConfigurationToClientPacketCommonSettings) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Locale) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ViewDistance) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.ChatFlags) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.ChatColors) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.SkinParts) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.MainHand) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableTextFiltering) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.EnableServerListing) + if err != nil { + return + } + var vConfigurationToClientPacketCommonSettingsParticleStatus int32 + vConfigurationToClientPacketCommonSettingsParticleStatus, err = proto_base.ErroringIndex(ConfigurationToClientPacketCommonSettingsParticleStatusReverseMap, ret.ParticleStatus) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, vConfigurationToClientPacketCommonSettingsParticleStatus) + if err != nil { + return + } + return +} + +type ConfigurationToClientPacketCommonStoreCookie struct { + Key string + Value ByteArray +} + +func (ret *ConfigurationToClientPacketCommonStoreCookie) Decode(r io.Reader) (err error) { + ret.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Value.Decode(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToClientPacketCommonStoreCookie) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Key) + if err != nil { + return + } + err = ret.Value.Encode(w) + if err != nil { + return + } + return +} + +type ConfigurationToClientPacketCommonTransfer struct { + Host string + Port int32 +} + +func (ret *ConfigurationToClientPacketCommonTransfer) Decode(r io.Reader) (err error) { + ret.Host, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Port, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToClientPacketCommonTransfer) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Host) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, ret.Port) + if err != nil { + return + } + return +} + +type ConfigurationToClientPacketCustomPayload struct { + Channel string + Data proto_base.RestBuffer +} + +func (ret *ConfigurationToClientPacketCustomPayload) Decode(r io.Reader) (err error) { + ret.Channel, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ret.Data.Decode(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToClientPacketCustomPayload) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Channel) + if err != nil { + return + } + err = ret.Data.Encode(w) + if err != nil { + return + } + return +} + +type ConfigurationToClientPacketDisconnect struct { + Reason nbt.Anon +} + +func (ret *ConfigurationToClientPacketDisconnect) Decode(r io.Reader) (err error) { + err = ret.Reason.Decode(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToClientPacketDisconnect) Encode(w io.Writer) (err error) { + err = ret.Reason.Encode(w) + if err != nil { + return + } + return +} + +type ConfigurationToClientPacketFeatureFlags struct { + Features []string +} + +func (ret *ConfigurationToClientPacketFeatureFlags) Decode(r io.Reader) (err error) { + var lConfigurationToClientPacketFeatureFlagsFeatures int32 + lConfigurationToClientPacketFeatureFlagsFeatures, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Features = []string{} + for range lConfigurationToClientPacketFeatureFlagsFeatures { + var ConfigurationToClientPacketFeatureFlagsFeaturesElement string + ConfigurationToClientPacketFeatureFlagsFeaturesElement, err = proto_base.DecodeString(r) + if err != nil { + return + } + ret.Features = append(ret.Features, ConfigurationToClientPacketFeatureFlagsFeaturesElement) + } + return +} +func (ret *ConfigurationToClientPacketFeatureFlags) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Features))) + if err != nil { + return + } + for iConfigurationToClientPacketFeatureFlagsFeatures := range len(ret.Features) { + err = proto_base.EncodeString(w, ret.Features[iConfigurationToClientPacketFeatureFlagsFeatures]) + if err != nil { + return + } + } + return +} + +type ConfigurationToClientPacketFinishConfiguration struct { +} + +func (ret *ConfigurationToClientPacketFinishConfiguration) Decode(r io.Reader) (err error) { + return +} +func (ret *ConfigurationToClientPacketFinishConfiguration) Encode(w io.Writer) (err error) { + return +} + +type ConfigurationToClientPacketKeepAlive struct { + KeepAliveId int64 +} + +func (ret *ConfigurationToClientPacketKeepAlive) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.KeepAliveId) + if err != nil { + return + } + return +} +func (ret *ConfigurationToClientPacketKeepAlive) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.KeepAliveId) + if err != nil { + return + } + return +} + +type ConfigurationToClientPacketPing struct { + Id int32 +} + +func (ret *ConfigurationToClientPacketPing) Decode(r io.Reader) (err error) { + err = binary.Read(r, binary.BigEndian, &ret.Id) + if err != nil { + return + } + return +} +func (ret *ConfigurationToClientPacketPing) Encode(w io.Writer) (err error) { + err = binary.Write(w, binary.BigEndian, ret.Id) + if err != nil { + return + } + return +} + +type ConfigurationToClientPacketRegistryData struct { + Id string + Entries []struct { + Key string + Value *nbt.Anon + } +} + +func (ret *ConfigurationToClientPacketRegistryData) Decode(r io.Reader) (err error) { + ret.Id, err = proto_base.DecodeString(r) + if err != nil { + return + } + var lConfigurationToClientPacketRegistryDataEntries int32 + lConfigurationToClientPacketRegistryDataEntries, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Entries = []struct { + Key string + Value *nbt.Anon + }{} + for range lConfigurationToClientPacketRegistryDataEntries { + var ConfigurationToClientPacketRegistryDataEntriesElement struct { + Key string + Value *nbt.Anon + } + ConfigurationToClientPacketRegistryDataEntriesElement.Key, err = proto_base.DecodeString(r) + if err != nil { + return + } + var ConfigurationToClientPacketRegistryDataEntriesElementValuePresent bool + err = binary.Read(r, binary.BigEndian, &ConfigurationToClientPacketRegistryDataEntriesElementValuePresent) + if err != nil { + return + } + if ConfigurationToClientPacketRegistryDataEntriesElementValuePresent { + var ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue nbt.Anon + err = ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue.Decode(r) + if err != nil { + return + } + ConfigurationToClientPacketRegistryDataEntriesElement.Value = &ConfigurationToClientPacketRegistryDataEntriesElementValuePresentValue + } + ret.Entries = append(ret.Entries, ConfigurationToClientPacketRegistryDataEntriesElement) + } + return +} +func (ret *ConfigurationToClientPacketRegistryData) Encode(w io.Writer) (err error) { + err = proto_base.EncodeString(w, ret.Id) + if err != nil { + return + } + err = proto_base.EncodeVarInt(w, int32(len(ret.Entries))) + if err != nil { + return + } + for iConfigurationToClientPacketRegistryDataEntries := range len(ret.Entries) { + err = proto_base.EncodeString(w, ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Key) + if err != nil { + return + } + err = binary.Write(w, binary.BigEndian, ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value != nil) + if err != nil { + return + } + if ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value != nil { + err = (*ret.Entries[iConfigurationToClientPacketRegistryDataEntries].Value).Encode(w) + if err != nil { + return + } + } + } + return +} + +type ConfigurationToClientPacketResetChat struct { +} + +func (ret *ConfigurationToClientPacketResetChat) Decode(r io.Reader) (err error) { + return +} +func (ret *ConfigurationToClientPacketResetChat) Encode(w io.Writer) (err error) { + return +} + +type ConfigurationToClientPacketShowDialog struct { + Dialog nbt.Anon +} + +func (ret *ConfigurationToClientPacketShowDialog) Decode(r io.Reader) (err error) { + err = ret.Dialog.Decode(r) + if err != nil { + return + } + return +} +func (ret *ConfigurationToClientPacketShowDialog) Encode(w io.Writer) (err error) { + err = ret.Dialog.Encode(w) + if err != nil { + return + } + return +} + +type ConfigurationToClientPacketTags struct { + Tags []struct { + TagType string + Tags Tags + } +} + +func (ret *ConfigurationToClientPacketTags) Decode(r io.Reader) (err error) { + var lConfigurationToClientPacketTagsTags int32 + lConfigurationToClientPacketTagsTags, err = proto_base.DecodeVarInt(r) + if err != nil { + return + } + ret.Tags = []struct { + TagType string + Tags Tags + }{} + for range lConfigurationToClientPacketTagsTags { + var ConfigurationToClientPacketTagsTagsElement struct { + TagType string + Tags Tags + } + ConfigurationToClientPacketTagsTagsElement.TagType, err = proto_base.DecodeString(r) + if err != nil { + return + } + err = ConfigurationToClientPacketTagsTagsElement.Tags.Decode(r) + if err != nil { + return + } + ret.Tags = append(ret.Tags, ConfigurationToClientPacketTagsTagsElement) + } + return +} +func (ret *ConfigurationToClientPacketTags) Encode(w io.Writer) (err error) { + err = proto_base.EncodeVarInt(w, int32(len(ret.Tags))) + if err != nil { + return + } + for iConfigurationToClientPacketTagsTags := range len(ret.Tags) { + err = proto_base.EncodeString(w, ret.Tags[iConfigurationToClientPacketTagsTags].TagType) + if err != nil { + return + } + err = ret.Tags[iConfigurationToClientPacketTagsTags].Tags.Encode(w) + if err != nil { + return + } + } + return +}